minix/servers/inet/qp.c

385 lines
7.1 KiB
C
Raw Normal View History

/*
inet/qp.c
Query parameters
Created: June 1995 by Philip Homburg <philip@f-mnx.phicoh.com>
*/
#include "inet.h"
#include "generic/assert.h"
#include <sys/svrctl.h>
#include <minix3/queryparam.h>
#include "generic/buf.h"
#include "generic/clock.h"
#include "generic/event.h"
#include "generic/type.h"
#include "generic/sr.h"
#include "generic/tcp_int.h"
#include "generic/udp_int.h"
#include "mq.h"
#include "qp.h"
#include "sr_int.h"
THIS_FILE
#define MAX_REQ 1024 /* Maximum size of a request */
#define QP_FD_NR 4
typedef struct qp_fd
{
int qf_flags;
int qf_srfd;
get_userdata_t qf_get_userdata;
put_userdata_t qf_put_userdata;
acc_t *qf_req_pkt;
} qp_fd_t;
#define QFF_EMPTY 0
#define QFF_INUSE 1
PRIVATE qp_fd_t qp_fd_table[QP_FD_NR];
PRIVATE struct export_param_list inet_ex_list[]=
{
QP_VARIABLE(sr_fd_table),
QP_VARIABLE(ip_dev),
QP_VARIABLE(tcp_fd_table),
QP_VARIABLE(tcp_conn_table),
QP_VARIABLE(tcp_cancel_f),
QP_VECTOR(udp_port_table, udp_port_table, ip_conf_nr),
QP_VARIABLE(udp_fd_table),
QP_END()
};
PRIVATE struct export_params inet_ex_params= { inet_ex_list, NULL };
PRIVATE struct queryvars {
/* Input */
acc_t *param;
/* Output */
qp_fd_t *qp_fd;
off_t fd_offset;
size_t rd_bytes_left;
off_t outbuf_off;
char outbuf[256];
int r; /* result */
} *qvars;
FORWARD int qp_open ARGS(( int port, int srfd,
get_userdata_t get_userdata, put_userdata_t put_userdata,
put_pkt_t put_pkt, select_res_t select_res ));
FORWARD void qp_close ARGS(( int fd ));
FORWARD int qp_read ARGS(( int fd, size_t count ));
FORWARD int qp_write ARGS(( int fd, size_t count ));
FORWARD int qp_ioctl ARGS(( int fd, ioreq_t req ));
FORWARD int qp_cancel ARGS(( int fd, int which_operation ));
FORWARD int qp_select ARGS(( int fd, unsigned operations ));
FORWARD qp_fd_t *get_qp_fd ARGS(( int fd ));
FORWARD int do_query ARGS(( qp_fd_t *qp_fd, acc_t *pkt, int count ));
FORWARD int qp_getc ARGS(( void ));
FORWARD void qp_putc ARGS(( struct queryvars *qv, int c ));
FORWARD void qp_buffree ARGS(( int priority ));
#ifdef BUF_CONSISTENCY_CHECK
FORWARD void qp_bufcheck ARGS(( void ));
#endif
PUBLIC void qp_init()
{
int i;
qp_export(&inet_ex_params);
for (i= 0; i<QP_FD_NR; i++)
qp_fd_table[i].qf_flags= QFF_EMPTY;
#ifndef BUF_CONSISTENCY_CHECK
bf_logon(qp_buffree);
#else
bf_logon(qp_buffree, qp_bufcheck);
#endif
sr_add_minor(IPSTAT_MINOR, 0, qp_open, qp_close, qp_read, qp_write,
qp_ioctl, qp_cancel, qp_select);
}
PRIVATE int qp_open(port, srfd, get_userdata, put_userdata, put_pkt,
select_res)
int port;
int srfd;
get_userdata_t get_userdata;
put_userdata_t put_userdata;
put_pkt_t put_pkt;
select_res_t select_res;
{
int i;
qp_fd_t *qp_fd;
for (i= 0; i< QP_FD_NR; i++)
{
if (!(qp_fd_table[i].qf_flags & QFF_INUSE))
break;
}
if (i >= QP_FD_NR)
return EAGAIN;
qp_fd= &qp_fd_table[i];
qp_fd->qf_flags= QFF_INUSE;
qp_fd->qf_srfd= srfd;
qp_fd->qf_get_userdata= get_userdata;
qp_fd->qf_put_userdata= put_userdata;
qp_fd->qf_req_pkt= NULL;
return i;
}
PRIVATE void qp_close(fd)
int fd;
{
qp_fd_t *qp_fd;
qp_fd= get_qp_fd(fd);
qp_fd->qf_flags= QFF_EMPTY;
if (qp_fd->qf_req_pkt)
{
bf_afree(qp_fd->qf_req_pkt);
qp_fd->qf_req_pkt= NULL;
}
}
PRIVATE int qp_read(fd, count)
int fd;
size_t count;
{
int r;
acc_t *pkt;
qp_fd_t *qp_fd;
qp_fd= get_qp_fd(fd);
pkt= qp_fd->qf_req_pkt;
qp_fd->qf_req_pkt= NULL;
if (!pkt)
{
/* Nothing to do */
qp_fd->qf_put_userdata(qp_fd->qf_srfd, EIO, 0,
FALSE /* !for_ioctl*/);
return OK;
}
r= do_query(qp_fd, pkt, count);
qp_fd->qf_put_userdata(qp_fd->qf_srfd, r, 0,
FALSE /* !for_ioctl*/);
return OK;
}
PRIVATE int qp_write(fd, count)
int fd;
size_t count;
{
acc_t *pkt;
qp_fd_t *qp_fd;
qp_fd= get_qp_fd(fd);
if (count > MAX_REQ)
{
qp_fd->qf_get_userdata(qp_fd->qf_srfd, ENOMEM, 0,
FALSE /* !for_ioctl*/);
return OK;
}
pkt= qp_fd->qf_get_userdata(qp_fd->qf_srfd, 0, count,
FALSE /* !for_ioctl*/);
if (!pkt)
{
qp_fd->qf_get_userdata(qp_fd->qf_srfd, EFAULT, 0,
FALSE /* !for_ioctl*/);
return OK;
}
if (qp_fd->qf_req_pkt)
{
bf_afree(qp_fd->qf_req_pkt);
qp_fd->qf_req_pkt= NULL;
}
qp_fd->qf_req_pkt= pkt;
qp_fd->qf_get_userdata(qp_fd->qf_srfd, count, 0,
FALSE /* !for_ioctl*/);
return OK;
}
PRIVATE int qp_ioctl(fd, req)
int fd;
ioreq_t req;
{
qp_fd_t *qp_fd;
qp_fd= get_qp_fd(fd);
qp_fd->qf_get_userdata(qp_fd->qf_srfd, ENOTTY, 0,
TRUE /* for_ioctl*/);
return OK;
}
PRIVATE int qp_cancel(fd, which_operation)
int fd;
int which_operation;
{
ip_panic(( "qp_cancel: should not be here, no blocking calls" ));
}
PRIVATE int qp_select(fd, operations)
int fd;
unsigned operations;
{
unsigned resops;
resops= 0;
if (operations & SR_SELECT_READ)
resops |= SR_SELECT_READ;
if (operations & SR_SELECT_WRITE)
resops |= SR_SELECT_WRITE;
return resops;
}
PRIVATE qp_fd_t *get_qp_fd(fd)
int fd;
{
qp_fd_t *qp_fd;
assert(fd >= 0 && fd < QP_FD_NR);
qp_fd= &qp_fd_table[fd];
assert(qp_fd->qf_flags & QFF_INUSE);
return qp_fd;
}
PRIVATE int do_query(qp_fd, pkt, count)
qp_fd_t *qp_fd;
acc_t *pkt;
int count;
{
struct queryvars qv;
void *addr;
size_t n, size;
int byte;
int more;
static char hex[]= "0123456789ABCDEF";
qvars= &qv;
qv.param= pkt; pkt= NULL;
qv.qp_fd= qp_fd;
qv.fd_offset= 0;
qv.outbuf_off= 0;
qv.rd_bytes_left= count;
qv.r= 0;
do {
more= queryparam(qp_getc, &addr, &size);
for (n= 0; n < size; n++) {
byte= ((u8_t *) addr)[n];
qp_putc(&qv, hex[byte >> 4]);
qp_putc(&qv, hex[byte & 0x0F]);
}
qp_putc(&qv, more ? ',' : 0);
if (qv.r)
break;
} while (more);
if (qv.param)
{
assert(0);
bf_afree(qv.param);
qv.param= NULL;
}
if (qv.r)
return qv.r;
return qv.fd_offset;
}
PRIVATE int qp_getc()
{
/* Return one character of the names to search for. */
acc_t *pkt;
struct queryvars *qv= qvars;
u8_t c;
pkt= qv->param;
qv->param= NULL;
if (pkt == NULL)
return 0;
assert(bf_bufsize(pkt) > 0);
c= ptr2acc_data(pkt)[0];
if (bf_bufsize(pkt) > 1)
qv->param= bf_delhead(pkt, 1);
else
{
bf_afree(pkt);
qv->param= NULL;
}
return c;
}
PRIVATE void qp_putc(qv, c)
struct queryvars *qv;
int c;
{
/* Send one character back to the user. */
acc_t *pkt;
qp_fd_t *qp_fd;
size_t bytes_left;
off_t off;
bytes_left= qv->rd_bytes_left;
if (qv->r || bytes_left == 0)
return;
off= qv->outbuf_off;
assert(off < sizeof(qv->outbuf));
qv->outbuf[off]= c;
off++;
bytes_left--;
qv->rd_bytes_left= bytes_left;
if (c != '\0' && off < sizeof(qv->outbuf) && bytes_left != 0)
{
qv->outbuf_off= off;
return;
}
pkt= bf_memreq(off);
assert(pkt->acc_next == NULL);
memcpy(ptr2acc_data(pkt), qv->outbuf, off);
qp_fd= qv->qp_fd;
qv->r= qp_fd->qf_put_userdata(qp_fd->qf_srfd, qv->fd_offset,
pkt, FALSE /* !for_ioctl*/ );
qv->fd_offset += off;
qv->outbuf_off= 0;
}
PRIVATE void qp_buffree (priority)
int priority;
{
/* For the moment, we are not going to free anything */
}
#ifdef BUF_CONSISTENCY_CHECK
PRIVATE void qp_bufcheck()
{
int i;
qp_fd_t *qp_fd;
for (i= 0, qp_fd= qp_fd_table; i<QP_FD_NR; i++, qp_fd++)
{
if (!(qp_fd->qf_flags & QFF_INUSE))
continue;
if (qp_fd->qf_req_pkt)
bf_check_acc(qp_fd->qf_req_pkt);
}
}
#endif
/*
* $PchId: qp.c,v 1.7 2005/06/28 14:25:25 philip Exp $
*/