servers/inet/qp.c

   1 /*
   2 inet/qp.c
   3
   4 Query parameters
   5
   6 Created:        June 1995 by Philip Homburg <philip@f-mnx.phicoh.com>
   7 */
   8
   9 #include "inet.h"
  10 #include "generic/assert.h"
  11
  12 #include <sys/svrctl.h>
  13 #include "queryparam.h"
  14
  15 #include "generic/buf.h"
  16 #include "generic/clock.h"
  17 #include "generic/event.h"
  18 #include "generic/type.h"
  19 #include "generic/sr.h"
  20
  21 #include "generic/tcp_int.h"
  22 #include "generic/udp_int.h"
  23 #include "mq.h"
  24 #include "qp.h"
  25 #include "sr_int.h"
  26
  27 THIS_FILE
  28
  29 #define MAX_REQ 1024    /* Maximum size of a request */
  30
  31 #define QP_FD_NR        4
  32
  33 typedef struct qp_fd
  34 {
  35         int qf_flags;
  36         int qf_srfd;
  37         get_userdata_t qf_get_userdata;
  38         put_userdata_t qf_put_userdata;
  39         acc_t *qf_req_pkt;
  40 } qp_fd_t;
  41
  42 #define QFF_EMPTY       0
  43 #define QFF_INUSE       1
  44
  45 static qp_fd_t qp_fd_table[QP_FD_NR];
  46
  47 static struct export_param_list inet_ex_list[]=
  48 {
  49         QP_VARIABLE(sr_fd_table),
  50         QP_VARIABLE(ip_dev),
  51         QP_VARIABLE(tcp_fd_table),
  52         QP_VARIABLE(tcp_conn_table),
  53         QP_VARIABLE(tcp_cancel_f),
  54         QP_VECTOR(udp_port_table, udp_port_table, ip_conf_nr),
  55         QP_VARIABLE(udp_fd_table),
  56         QP_END()
  57 };
  58
  59 static struct export_params inet_ex_params= { inet_ex_list, NULL };
  60
  61 static struct queryvars {
  62         /* Input */
  63         acc_t *param;
  64
  65         /* Output */
  66         qp_fd_t *qp_fd;
  67         off_t fd_offset;
  68         size_t rd_bytes_left;
  69         off_t outbuf_off;
  70         char outbuf[256];
  71
  72         int r;  /* result */
  73 } *qvars;
  74
  75
  76 static int  qp_open ARGS(( int port, int srfd,
  77         get_userdata_t get_userdata, put_userdata_t put_userdata,
  78         put_pkt_t put_pkt, select_res_t select_res ));
  79 static void qp_close ARGS(( int fd ));
  80 static int qp_read ARGS(( int fd, size_t count ));
  81 static int qp_write ARGS(( int fd, size_t count ));
  82 static int qp_ioctl ARGS(( int fd, ioreq_t req ));
  83 static int qp_cancel ARGS(( int fd, int which_operation ));
  84 static int qp_select ARGS(( int fd, unsigned operations ));
  85 static qp_fd_t *get_qp_fd ARGS(( int fd ));
  86 static int do_query ARGS(( qp_fd_t *qp_fd, acc_t *pkt, int count ));
  87 static int qp_getc ARGS(( void ));
  88 static void qp_putc ARGS(( struct queryvars *qv, int c ));
  89 static void qp_buffree ARGS(( int priority ));
  90 #ifdef BUF_CONSISTENCY_CHECK
  91 static void qp_bufcheck ARGS(( void ));
  92 #endif
  93
  94 void qp_init()
  95 {
  96         int i;
  97
  98         qp_export(&inet_ex_params);
  99
 100         for (i= 0; i<QP_FD_NR; i++)
 101                 qp_fd_table[i].qf_flags= QFF_EMPTY;
 102
 103 #ifndef BUF_CONSISTENCY_CHECK
 104         bf_logon(qp_buffree);
 105 #else
 106         bf_logon(qp_buffree, qp_bufcheck);
 107 #endif
 108
 109         sr_add_minor(IPSTAT_MINOR, 0, qp_open, qp_close, qp_read, qp_write,
 110                 qp_ioctl, qp_cancel, qp_select);
 111 }
 112
 113 static int qp_open(port, srfd, get_userdata, put_userdata, put_pkt,
 114         select_res)
 115 int port;
 116 int srfd;
 117 get_userdata_t get_userdata;
 118 put_userdata_t put_userdata;
 119 put_pkt_t put_pkt;
 120 select_res_t select_res;
 121 {
 122         int i;
 123         qp_fd_t *qp_fd;
 124
 125         for (i= 0; i< QP_FD_NR; i++)
 126         {
 127                 if (!(qp_fd_table[i].qf_flags & QFF_INUSE))
 128                         break;
 129         }
 130         if (i >= QP_FD_NR)
 131                 return EAGAIN;
 132         qp_fd= &qp_fd_table[i];
 133         qp_fd->qf_flags= QFF_INUSE;
 134         qp_fd->qf_srfd= srfd;
 135         qp_fd->qf_get_userdata= get_userdata;
 136         qp_fd->qf_put_userdata= put_userdata;
 137         qp_fd->qf_req_pkt= NULL;
 138
 139         return i;
 140 }
 141
 142 static void qp_close(fd)
 143 int fd;
 144 {
 145         qp_fd_t *qp_fd;
 146
 147         qp_fd= get_qp_fd(fd);
 148         qp_fd->qf_flags= QFF_EMPTY;
 149         if (qp_fd->qf_req_pkt)
 150         {
 151                 bf_afree(qp_fd->qf_req_pkt);
 152                 qp_fd->qf_req_pkt= NULL;
 153         }
 154 }
 155
 156 static int qp_read(fd, count)
 157 int fd;
 158 size_t count;
 159 {
 160         int r;
 161         acc_t *pkt;
 162         qp_fd_t *qp_fd;
 163
 164         qp_fd= get_qp_fd(fd);
 165         pkt= qp_fd->qf_req_pkt;
 166         qp_fd->qf_req_pkt= NULL;
 167         if (!pkt)
 168         {
 169                 /* Nothing to do */
 170                 qp_fd->qf_put_userdata(qp_fd->qf_srfd, EIO, 0,
 171                         FALSE /* !for_ioctl*/);
 172                 return OK;
 173         }
 174         r= do_query(qp_fd, pkt, count);
 175         qp_fd->qf_put_userdata(qp_fd->qf_srfd, r, 0,
 176                         FALSE /* !for_ioctl*/);
 177         return OK;
 178 }
 179
 180 static int qp_write(fd, count)
 181 int fd;
 182 size_t count;
 183 {
 184         acc_t *pkt;
 185         qp_fd_t *qp_fd;
 186
 187         qp_fd= get_qp_fd(fd);
 188         if (count > MAX_REQ)
 189         {
 190                 qp_fd->qf_get_userdata(qp_fd->qf_srfd, ENOMEM, 0,
 191                         FALSE /* !for_ioctl*/);
 192                 return OK;
 193         }
 194         pkt= qp_fd->qf_get_userdata(qp_fd->qf_srfd, 0, count,
 195                 FALSE /* !for_ioctl*/);
 196         if (!pkt)
 197         {
 198                 qp_fd->qf_get_userdata(qp_fd->qf_srfd, EFAULT, 0,
 199                         FALSE /* !for_ioctl*/);
 200                 return OK;
 201         }
 202         if (qp_fd->qf_req_pkt)
 203         {
 204                 bf_afree(qp_fd->qf_req_pkt);
 205                 qp_fd->qf_req_pkt= NULL;
 206         }
 207         qp_fd->qf_req_pkt= pkt;
 208         qp_fd->qf_get_userdata(qp_fd->qf_srfd, count, 0,
 209                 FALSE /* !for_ioctl*/);
 210         return OK;
 211 }
 212
 213 static int qp_ioctl(fd, req)
 214 int fd;
 215 ioreq_t req;
 216 {
 217         qp_fd_t *qp_fd;
 218
 219         qp_fd= get_qp_fd(fd);
 220         qp_fd->qf_get_userdata(qp_fd->qf_srfd, ENOTTY, 0,
 221                         TRUE /* for_ioctl*/);
 222         return OK;
 223 }
 224
 225 static int qp_cancel(fd, which_operation)
 226 int fd;
 227 int which_operation;
 228 {
 229         ip_panic(( "qp_cancel: should not be here, no blocking calls" ));
 230         return OK;
 231 }
 232
 233 static int qp_select(fd, operations)
 234 int fd;
 235 unsigned operations;
 236 {
 237         unsigned resops;
 238
 239         resops= 0;
 240         if (operations & SR_SELECT_READ)
 241                 resops |= SR_SELECT_READ;
 242         if (operations & SR_SELECT_WRITE)
 243                 resops |= SR_SELECT_WRITE;
 244         return resops;
 245 }
 246
 247 static qp_fd_t *get_qp_fd(fd)
 248 int fd;
 249 {
 250         qp_fd_t *qp_fd;
 251
 252         assert(fd >= 0 && fd < QP_FD_NR);
 253         qp_fd= &qp_fd_table[fd];
 254         assert(qp_fd->qf_flags & QFF_INUSE);
 255         return qp_fd;
 256 }
 257
 258 static int do_query(qp_fd, pkt, count)
 259 qp_fd_t *qp_fd;
 260 acc_t *pkt;
 261 int count;
 262 {
 263         struct queryvars qv;
 264         void *addr;
 265         size_t n, size;
 266         int byte;
 267         int more;
 268         static char hex[]= "0123456789ABCDEF";
 269
 270         qvars= &qv;
 271         qv.param= pkt; pkt= NULL;
 272         qv.qp_fd= qp_fd;
 273         qv.fd_offset= 0;
 274         qv.outbuf_off= 0;
 275         qv.rd_bytes_left= count;
 276         qv.r= 0;
 277
 278         do {
 279                 more= queryparam(qp_getc, &addr, &size);
 280                 for (n= 0; n < size; n++) {
 281                         byte= ((u8_t *) addr)[n];
 282                         qp_putc(&qv, hex[byte >> 4]);
 283                         qp_putc(&qv, hex[byte & 0x0F]);
 284                 }
 285                 qp_putc(&qv, more ? ',' : 0);
 286                 if (qv.r)
 287                         break;
 288         } while (more);
 289         if (qv.param)
 290         {
 291                 assert(0);
 292                 bf_afree(qv.param);
 293                 qv.param= NULL;
 294         }
 295         if (qv.r)
 296                 return qv.r;
 297         return qv.fd_offset;
 298 }
 299
 300 static int qp_getc()
 301 {
 302         /* Return one character of the names to search for. */
 303         acc_t *pkt;
 304         struct queryvars *qv= qvars;
 305         u8_t c;
 306
 307         pkt= qv->param;
 308         qv->param= NULL;
 309         if (pkt == NULL)
 310                 return 0;
 311
 312         assert(bf_bufsize(pkt) > 0);
 313         c= ptr2acc_data(pkt)[0];
 314         if (bf_bufsize(pkt) > 1)
 315                 qv->param= bf_delhead(pkt, 1);
 316         else
 317         {
 318                 bf_afree(pkt);
 319                 qv->param= NULL;
 320         }
 321
 322         return c;
 323 }
 324
 325 static void qp_putc(qv, c)
 326 struct queryvars *qv;
 327 int c;
 328 {
 329         /* Send one character back to the user. */
 330         acc_t *pkt;
 331         qp_fd_t *qp_fd;
 332         size_t bytes_left;
 333         off_t off;
 334
 335         bytes_left= qv->rd_bytes_left;
 336         if (qv->r || bytes_left == 0)
 337                 return;
 338
 339         off= qv->outbuf_off;
 340         assert(off < sizeof(qv->outbuf));
 341         qv->outbuf[off]= c;
 342         off++;
 343         bytes_left--;
 344         qv->rd_bytes_left= bytes_left;
 345         if (c != '\0' && off < sizeof(qv->outbuf) && bytes_left != 0)
 346         {
 347                 qv->outbuf_off= off;
 348                 return;
 349         }
 350
 351         pkt= bf_memreq(off);
 352         assert(pkt->acc_next == NULL);
 353         memcpy(ptr2acc_data(pkt), qv->outbuf, off);
 354         qp_fd= qv->qp_fd;
 355         qv->r= qp_fd->qf_put_userdata(qp_fd->qf_srfd, qv->fd_offset,
 356                 pkt, FALSE /* !for_ioctl*/ );
 357         qv->fd_offset += off;
 358         qv->outbuf_off= 0;
 359 }
 360
 361 static void qp_buffree (priority)
 362 int priority;
 363 {
 364         /* For the moment, we are not going to free anything */
 365 }
 366
 367 #ifdef BUF_CONSISTENCY_CHECK
 368 static void qp_bufcheck()
 369 {
 370         int i;
 371         qp_fd_t *qp_fd;
 372
 373         for (i= 0, qp_fd= qp_fd_table; i<QP_FD_NR; i++, qp_fd++)
 374         {
 375                 if (!(qp_fd->qf_flags & QFF_INUSE))
 376                         continue;
 377                 if (qp_fd->qf_req_pkt)
 378                         bf_check_acc(qp_fd->qf_req_pkt);
 379         }
 380 }
 381 #endif
 382
 383 /*
 384  * $PchId: qp.c,v 1.7 2005/06/28 14:25:25 philip Exp $
 385  */