servers/inet/generic/psip.c

   1 /*
   2 generic/psip.c
   3
   4 Implementation of a pseudo IP device.
   5
   6 Created:        Apr 22, 1993 by Philip Homburg
   7
   8 Copyright 1995 Philip Homburg
   9 */
  10
  11 #include "inet.h"
  12 #include "assert.h"
  13 #include "buf.h"
  14 #include "event.h"
  15 #include "type.h"
  16 #include "ip_int.h"
  17 #include "psip.h"
  18 #include "sr.h"
  19
  20 THIS_FILE
  21
  22 typedef struct psip_port
  23 {
  24         int pp_flags;
  25         int pp_ipdev;
  26         int pp_opencnt;
  27         struct psip_fd *pp_rd_head;
  28         struct psip_fd *pp_rd_tail;
  29         acc_t *pp_promisc_head;
  30         acc_t *pp_promisc_tail;
  31 } psip_port_t;
  32
  33 #define PPF_EMPTY       0
  34 #define PPF_CONFIGURED  1
  35 #define PPF_ENABLED     2
  36 #define PPF_PROMISC     4
  37
  38 #define PSIP_FD_NR      (1*IP_PORT_MAX)
  39
  40 typedef struct psip_fd
  41 {
  42         int pf_flags;
  43         int pf_srfd;
  44         psip_port_t *pf_port;
  45         get_userdata_t pf_get_userdata;
  46         put_userdata_t pf_put_userdata;
  47         struct psip_fd *pf_rd_next;
  48         size_t pf_rd_count;
  49         nwio_psipopt_t pf_psipopt;
  50 } psip_fd_t;
  51
  52 #define PFF_EMPTY       0
  53 #define PFF_INUSE       1
  54 #define PFF_READ_IP     2
  55 #define PFF_PROMISC     4
  56 #define PFF_NEXTHOP     8
  57
  58 static psip_port_t *psip_port_table;
  59 static psip_fd_t psip_fd_table[PSIP_FD_NR];
  60
  61 static int psip_open ARGS(( int port, int srfd,
  62         get_userdata_t get_userdata, put_userdata_t put_userdata,
  63         put_pkt_t pkt_pkt, select_res_t select_res ));
  64 static int psip_ioctl ARGS(( int fd, ioreq_t req ));
  65 static int psip_read ARGS(( int fd, size_t count ));
  66 static int psip_write ARGS(( int fd, size_t count ));
  67 static int psip_select ARGS(( int port_nr, unsigned operations ));
  68 static void psip_close ARGS(( int fd ));
  69 static int psip_cancel ARGS(( int fd, int which_operation ));
  70 static void promisc_restart_read ARGS(( psip_port_t *psip_port ));
  71 static int psip_setopt ARGS(( psip_fd_t *psip_fd, nwio_psipopt_t *newoptp ));
  72 static void psip_buffree ARGS(( int priority ));
  73 static void check_promisc ARGS(( psip_port_t *psip_port ));
  74 #ifdef BUF_CONSISTENCY_CHECK
  75 static void psip_bufcheck ARGS(( void ));
  76 #endif
  77 static void reply_thr_put ARGS(( psip_fd_t *psip_fd, int reply,
  78         int for_ioctl ));
  79 static void reply_thr_get ARGS(( psip_fd_t *psip_fd, int reply,
  80         int for_ioctl ));
  81
  82 void psip_prep()
  83 {
  84         psip_port_table= alloc(psip_conf_nr * sizeof(psip_port_table[0]));
  85 }
  86
  87 void psip_init()
  88 {
  89         int i;
  90         psip_port_t *psip_port;
  91         psip_fd_t *psip_fd;
  92
  93         for (i=0, psip_port= psip_port_table; i<psip_conf_nr; i++, psip_port++)
  94                 psip_port->pp_flags= PPF_EMPTY;
  95
  96         for (i=0, psip_fd= psip_fd_table; i<PSIP_FD_NR; i++, psip_fd++)
  97                 psip_fd->pf_flags= PFF_EMPTY;
  98
  99         for (i=0, psip_port= psip_port_table; i<psip_conf_nr; i++, psip_port++)
 100         {
 101                 psip_port->pp_flags |= PPF_CONFIGURED;
 102                 psip_port->pp_opencnt= 0;
 103                 psip_port->pp_rd_head= NULL;
 104                 psip_port->pp_promisc_head= NULL;
 105         }
 106
 107 #ifndef BUF_CONSISTENCY_CHECK
 108         bf_logon(psip_buffree);
 109 #else
 110         bf_logon(psip_buffree, psip_bufcheck);
 111 #endif
 112 }
 113
 114 int psip_enable(port_nr, ip_port_nr)
 115 int port_nr;
 116 int ip_port_nr;
 117 {
 118         psip_port_t *psip_port;
 119
 120         assert(port_nr >= 0);
 121         if (port_nr >= psip_conf_nr)
 122                 return -1;
 123
 124         psip_port= &psip_port_table[port_nr];
 125         if (!(psip_port->pp_flags &PPF_CONFIGURED))
 126                 return -1;
 127
 128         psip_port->pp_ipdev= ip_port_nr;
 129         psip_port->pp_flags |= PPF_ENABLED;
 130
 131         sr_add_minor(if2minor(psip_conf[port_nr].pc_ifno, PSIP_DEV_OFF),
 132                 port_nr, psip_open, psip_close, psip_read,
 133                 psip_write, psip_ioctl, psip_cancel, psip_select);
 134
 135         return NW_OK;
 136 }
 137
 138 int psip_send(port_nr, dest, pack)
 139 int port_nr;
 140 ipaddr_t dest;
 141 acc_t *pack;
 142 {
 143         psip_port_t *psip_port;
 144         psip_fd_t *psip_fd, *mark_fd;
 145         int i, result, result1;
 146         size_t buf_size, extrasize;
 147         acc_t *hdr_pack, *acc;
 148         psip_io_hdr_t *hdr;
 149
 150         assert(port_nr >= 0 && port_nr < psip_conf_nr);
 151         psip_port= &psip_port_table[port_nr];
 152
 153         if (psip_port->pp_opencnt == 0)
 154         {
 155                 bf_afree(pack);
 156                 return NW_OK;
 157         }
 158
 159         for(;;)
 160         {
 161                 mark_fd= psip_port->pp_rd_tail;
 162
 163                 for(i= 0; i<PSIP_FD_NR; i++)
 164                 {
 165                         psip_fd= psip_port->pp_rd_head;
 166                         if (!psip_fd)
 167                                 return NW_SUSPEND;
 168                         psip_port->pp_rd_head= psip_fd->pf_rd_next;
 169                         if (!(psip_fd->pf_flags & PFF_PROMISC))
 170                                 break;
 171                         psip_fd->pf_rd_next= NULL;
 172                         if (psip_port->pp_rd_head == NULL)
 173                                 psip_port->pp_rd_head= psip_fd;
 174                         else
 175                                 psip_port->pp_rd_tail->pf_rd_next= psip_fd;
 176                         psip_port->pp_rd_tail= psip_fd;
 177                         if (psip_fd == mark_fd)
 178                                 return NW_SUSPEND;
 179                 }
 180                 if (i == PSIP_FD_NR)
 181                         ip_panic(( "psip_send: loop" ));
 182
 183                 assert(psip_fd->pf_flags & PFF_READ_IP);
 184                 psip_fd->pf_flags &= ~PFF_READ_IP;
 185
 186                 if (psip_fd->pf_flags & PFF_NEXTHOP)
 187                         extrasize= sizeof(dest);
 188                 else
 189                         extrasize= 0;
 190
 191                 buf_size= bf_bufsize(pack);
 192                 if (buf_size+extrasize <= psip_fd->pf_rd_count)
 193                 {
 194                         if (psip_port->pp_flags & PPF_PROMISC)
 195                         {
 196                                 /* Deal with promiscuous mode. */
 197                                 hdr_pack= bf_memreq(sizeof(*hdr));
 198                                 hdr= (psip_io_hdr_t *)ptr2acc_data(hdr_pack);
 199                                 memset(hdr, '\0', sizeof(*hdr));
 200                                 hdr->pih_flags |= PF_LOC2REM;
 201                                 hdr->pih_nexthop= dest;
 202
 203                                 pack->acc_linkC++;
 204                                 hdr_pack->acc_next= pack;
 205                                 hdr_pack->acc_ext_link= NULL;
 206                                 if (psip_port->pp_promisc_head)
 207                                 {
 208                                         /* Append at the end. */
 209                                         psip_port->pp_promisc_tail->
 210                                                 acc_ext_link= hdr_pack;
 211                                         psip_port->pp_promisc_tail= hdr_pack;
 212                                 }
 213                                 else
 214                                 {
 215                                         /* First packet. */
 216                                         psip_port->pp_promisc_head= hdr_pack;
 217                                         psip_port->pp_promisc_tail= hdr_pack;
 218                                         if (psip_port->pp_rd_head)
 219                                             promisc_restart_read(psip_port);
 220                                 }
 221                         }
 222
 223                         if (extrasize)
 224                         {
 225                                 /* Prepend nexthop address */
 226                                 acc= bf_memreq(sizeof(dest));
 227                                 *(ipaddr_t *)(ptr2acc_data(acc))= dest;
 228                                 acc->acc_next= pack;
 229                                 pack= acc; acc= NULL;
 230                                 buf_size += extrasize;
 231                         }
 232
 233                         result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
 234                                 (size_t)0, pack, FALSE);
 235                         if (result == NW_OK)
 236                                 result= buf_size;
 237                 }
 238                 else
 239                         result= EPACKSIZE;
 240
 241                 result1= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
 242                                 (size_t)result, NULL, FALSE);
 243                 assert(result1 == NW_OK);
 244                 if (result == EPACKSIZE)
 245                         continue;
 246                 return NW_OK;
 247         }
 248         return NW_SUSPEND;
 249 }
 250
 251 static int psip_open(port, srfd, get_userdata, put_userdata, put_pkt,
 252         select_res)
 253 int port;
 254 int srfd;
 255 get_userdata_t get_userdata;
 256 put_userdata_t put_userdata;
 257 put_pkt_t put_pkt;
 258 select_res_t select_res;
 259 {
 260         psip_port_t *psip_port;
 261         psip_fd_t *psip_fd;
 262         int i;
 263
 264         assert(port >= 0 && port < psip_conf_nr);
 265         psip_port= &psip_port_table[port];
 266
 267         if (!(psip_port->pp_flags & PPF_ENABLED))
 268                 return ENXIO;
 269
 270         for (i= 0, psip_fd= psip_fd_table; i<PSIP_FD_NR; i++, psip_fd++)
 271         {
 272                 if (psip_fd->pf_flags & PFF_INUSE)
 273                         continue;
 274                 break;
 275         }
 276         if (i == PSIP_FD_NR)
 277                 return ENFILE;
 278         psip_fd->pf_flags |= PFF_INUSE;
 279         psip_fd->pf_srfd= srfd;
 280         psip_fd->pf_port= psip_port;
 281         psip_fd->pf_get_userdata= get_userdata;
 282         psip_fd->pf_put_userdata= put_userdata;
 283         psip_port->pp_opencnt++;
 284
 285         return i;
 286 }
 287
 288 static int psip_ioctl(fd, req)
 289 int fd;
 290 ioreq_t req;
 291 {
 292         int result;
 293         psip_fd_t *psip_fd;
 294         acc_t *data;
 295         nwio_ipconf_t *ipconfp;
 296         nwio_psipopt_t *psip_opt, *newoptp;
 297
 298         assert(fd >= 0 && fd < PSIP_FD_NR);
 299         psip_fd= &psip_fd_table[fd];
 300
 301         switch(req)
 302         {
 303         case NWIOSIPCONF:
 304                 data= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd, 0,
 305                         sizeof(*ipconfp), TRUE);
 306                 if (!data)
 307                 {
 308                         result= EFAULT;
 309                         break;
 310                 }
 311                 data= bf_packIffLess(data, sizeof(*ipconfp));
 312                 assert (data->acc_length == sizeof(*ipconfp));
 313
 314                 ipconfp= (nwio_ipconf_t *)ptr2acc_data(data);
 315                 result= ip_setconf(psip_fd->pf_port->pp_ipdev, ipconfp);
 316                 bf_afree(data);
 317                 reply_thr_get(psip_fd, result, TRUE);
 318                 break;
 319         case NWIOSPSIPOPT:
 320                 data= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd, 0,
 321                         sizeof(*psip_opt), TRUE);
 322                 if (!data)
 323                 {
 324                         result= EFAULT;
 325                         break;
 326                 }
 327                 data= bf_packIffLess(data, sizeof(*psip_opt));
 328                 assert (data->acc_length == sizeof(*psip_opt));
 329
 330                 newoptp= (nwio_psipopt_t *)ptr2acc_data(data);
 331                 result= psip_setopt(psip_fd, newoptp);
 332                 bf_afree(data);
 333                 if (result == NW_OK)
 334                 {
 335                         if (psip_fd->pf_psipopt.nwpo_flags & NWPO_EN_PROMISC)
 336                         {
 337                                 psip_fd->pf_flags |= PFF_PROMISC;
 338                                 psip_fd->pf_port->pp_flags |= PPF_PROMISC;
 339                         }
 340                         else
 341                         {
 342                                 psip_fd->pf_flags &= ~PFF_PROMISC;
 343                                 check_promisc(psip_fd->pf_port);
 344                         }
 345                         if (psip_fd->pf_psipopt.nwpo_flags & NWPO_EN_NEXTHOP)
 346                         {
 347                                 psip_fd->pf_flags |= PFF_NEXTHOP;
 348                         }
 349                         else
 350                         {
 351                                 psip_fd->pf_flags &= ~PFF_NEXTHOP;
 352                         }
 353                 }
 354                 reply_thr_get(psip_fd, result, TRUE);
 355                 break;
 356         case NWIOGPSIPOPT:
 357                 data= bf_memreq(sizeof(*psip_opt));
 358                 psip_opt= (nwio_psipopt_t *)ptr2acc_data(data);
 359
 360                 *psip_opt= psip_fd->pf_psipopt;
 361                 result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd, 0,
 362                         data, TRUE);
 363                 if (result == NW_OK)
 364                         reply_thr_put(psip_fd, NW_OK, TRUE);
 365                 break;
 366         default:
 367                 reply_thr_put(psip_fd, ENOTTY, TRUE);
 368                 break;
 369         }
 370         return NW_OK;
 371 }
 372
 373 static int psip_read(fd, count)
 374 int fd;
 375 size_t count;
 376 {
 377         psip_port_t *psip_port;
 378         psip_fd_t *psip_fd;
 379         acc_t *pack;
 380         size_t buf_size;
 381         int result, result1;
 382
 383         assert(fd >= 0 && fd < PSIP_FD_NR);
 384         psip_fd= &psip_fd_table[fd];
 385         psip_port= psip_fd->pf_port;
 386
 387         if ((psip_fd->pf_flags & PFF_PROMISC) && psip_port->pp_promisc_head)
 388         {
 389                 /* Deliver a queued packet. */
 390                 pack= psip_port->pp_promisc_head;
 391                 buf_size= bf_bufsize(pack);
 392                 if (buf_size <= count)
 393                 {
 394                         psip_port->pp_promisc_head= pack->acc_ext_link;
 395                         result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
 396                                 (size_t)0, pack, FALSE);
 397                         if (result == NW_OK)
 398                                 result= buf_size;
 399                 }
 400                 else
 401                         result= EPACKSIZE;
 402
 403                 result1= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
 404                                 (size_t)result, NULL, FALSE);
 405                 assert(result1 == NW_OK);
 406                 return NW_OK;
 407         }
 408
 409         psip_fd->pf_rd_count= count;
 410         if (psip_port->pp_rd_head == NULL)
 411                 psip_port->pp_rd_head= psip_fd;
 412         else
 413                 psip_port->pp_rd_tail->pf_rd_next= psip_fd;
 414         psip_fd->pf_rd_next= NULL;
 415         psip_port->pp_rd_tail= psip_fd;
 416
 417         psip_fd->pf_flags |= PFF_READ_IP;
 418         if (!(psip_fd->pf_flags & PFF_PROMISC))
 419                 ipps_get(psip_port->pp_ipdev);
 420         if (psip_fd->pf_flags & PFF_READ_IP)
 421                 return NW_SUSPEND;
 422         return NW_OK;
 423 }
 424
 425 static int psip_write(fd, count)
 426 int fd;
 427 size_t count;
 428 {
 429         psip_port_t *psip_port;
 430         psip_fd_t *psip_fd;
 431         acc_t *pack, *hdr_pack;
 432         psip_io_hdr_t *hdr;
 433         size_t pack_len;
 434         ipaddr_t nexthop;
 435
 436         assert(fd >= 0 && fd < PSIP_FD_NR);
 437         psip_fd= &psip_fd_table[fd];
 438         psip_port= psip_fd->pf_port;
 439
 440         pack= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd, (size_t)0,
 441                 count, FALSE);
 442         if (pack == NULL)
 443         {
 444                 pack= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd,
 445                         (size_t)EFAULT, (size_t)0, FALSE);
 446                 assert(pack == NULL);
 447                 return NW_OK;
 448         }
 449
 450         if (psip_fd->pf_flags & PFF_NEXTHOP)
 451         {
 452                 pack_len= bf_bufsize(pack);
 453                 if (pack_len <= sizeof(nexthop))
 454                 {
 455                         /* Something strange */
 456                         bf_afree(pack); pack= NULL;
 457                         pack= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd,
 458                                 (size_t)EPACKSIZE, (size_t)0, FALSE);
 459                         assert(pack == NULL);
 460                         return NW_OK;
 461                 }
 462                 pack= bf_packIffLess(pack, sizeof(nexthop));
 463                 nexthop= *(ipaddr_t *)ptr2acc_data(pack);
 464                 pack= bf_delhead(pack, sizeof(nexthop));
 465
 466                 /* Map multicast to broadcast */
 467                 if ((nexthop & HTONL(0xE0000000)) == HTONL(0xE0000000))
 468                         nexthop= HTONL(0xffffffff);
 469         }
 470         else
 471         {
 472                 /* Assume point to point */
 473                 nexthop= HTONL(0x00000000);
 474         }
 475
 476         if (psip_port->pp_flags & PPF_PROMISC)
 477         {
 478                 /* Deal with promiscuous mode. */
 479                 hdr_pack= bf_memreq(sizeof(*hdr));
 480                 hdr= (psip_io_hdr_t *)ptr2acc_data(hdr_pack);
 481                 memset(hdr, '\0', sizeof(*hdr));
 482                 hdr->pih_flags |= PF_REM2LOC;
 483                 hdr->pih_nexthop= nexthop;
 484
 485                 pack->acc_linkC++;
 486                 hdr_pack->acc_next= pack;
 487                 hdr_pack->acc_ext_link= NULL;
 488                 if (psip_port->pp_promisc_head)
 489                 {
 490                         /* Append at the end. */
 491                         psip_port->pp_promisc_tail->acc_ext_link= hdr_pack;
 492                         psip_port->pp_promisc_tail= hdr_pack;
 493                 }
 494                 else
 495                 {
 496                         /* First packet. */
 497                         psip_port->pp_promisc_head= hdr_pack;
 498                         psip_port->pp_promisc_tail= hdr_pack;
 499                         if (psip_port->pp_rd_head)
 500                                 promisc_restart_read(psip_port);
 501                 }
 502         }
 503         ipps_put(psip_port->pp_ipdev, nexthop, pack);
 504         pack= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd, (size_t)count,
 505                 (size_t)0, FALSE);
 506         assert(pack == NULL);
 507         return NW_OK;
 508 }
 509
 510 static int psip_select(fd, operations)
 511 int fd;
 512 unsigned operations;
 513 {
 514         printf("psip_select: not implemented\n");
 515         return 0;
 516 }
 517
 518 static void psip_close(fd)
 519 int fd;
 520 {
 521         psip_port_t *psip_port;
 522         psip_fd_t *psip_fd;
 523
 524         assert(fd >= 0 && fd < PSIP_FD_NR);
 525         psip_fd= &psip_fd_table[fd];
 526         psip_port= psip_fd->pf_port;
 527
 528         if (psip_fd->pf_flags & PFF_PROMISC)
 529         {
 530                 /* Check if the port should still be in promiscuous mode.
 531                  */
 532                 psip_fd->pf_flags &= ~PFF_PROMISC;
 533                 check_promisc(psip_fd->pf_port);
 534         }
 535
 536         assert(psip_port->pp_opencnt >0);
 537         psip_port->pp_opencnt--;
 538         psip_fd->pf_flags= PFF_EMPTY;
 539         ipps_get(psip_port->pp_ipdev);
 540
 541 }
 542
 543 static int psip_cancel(fd, which_operation)
 544 int fd;
 545 int which_operation;
 546 {
 547         psip_port_t *psip_port;
 548         psip_fd_t *psip_fd, *prev_fd, *tmp_fd;
 549         int result;
 550
 551         DBLOCK(1, printf("psip_cancel(%d, %d)\n", fd, which_operation));
 552
 553         assert(fd >= 0 && fd < PSIP_FD_NR);
 554         psip_fd= &psip_fd_table[fd];
 555         psip_port= psip_fd->pf_port;
 556
 557         switch(which_operation)
 558         {
 559         case SR_CANCEL_IOCTL:
 560                 ip_panic(( "should not be here" ));
 561         case SR_CANCEL_READ:
 562                 assert(psip_fd->pf_flags & PFF_READ_IP);
 563                 for (prev_fd= NULL, tmp_fd= psip_port->pp_rd_head; tmp_fd;
 564                         prev_fd= tmp_fd, tmp_fd= tmp_fd->pf_rd_next)
 565                 {
 566                         if (tmp_fd == psip_fd)
 567                                 break;
 568                 }
 569                 if (tmp_fd == NULL)
 570                         ip_panic(( "unable to find to request to cancel" ));
 571                 if (prev_fd == NULL)
 572                         psip_port->pp_rd_head= psip_fd->pf_rd_next;
 573                 else
 574                         prev_fd->pf_rd_next= psip_fd->pf_rd_next;
 575                 if (psip_fd->pf_rd_next == NULL)
 576                         psip_port->pp_rd_tail= prev_fd;
 577                 psip_fd->pf_flags &= ~PFF_READ_IP;
 578                 result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
 579                                                 (size_t)EINTR, NULL, FALSE);
 580                 assert(result == NW_OK);
 581                 break;
 582         case SR_CANCEL_WRITE:
 583                 ip_panic(( "should not be here" ));
 584         default:
 585                 ip_panic(( "invalid operation for cancel" ));
 586         }
 587         return NW_OK;
 588 }
 589
 590 static void promisc_restart_read(psip_port)
 591 psip_port_t *psip_port;
 592 {
 593         psip_fd_t *psip_fd, *prev, *next;
 594         acc_t *pack;
 595         size_t buf_size;
 596         int result, result1;
 597
 598         /* Overkill at the moment: just one reader in promiscious mode is
 599          * allowed.
 600          */
 601         pack= psip_port->pp_promisc_head;
 602         if (!pack)
 603                 return;
 604         assert(pack->acc_ext_link == NULL);
 605
 606         for(psip_fd= psip_port->pp_rd_head, prev= NULL; psip_fd;
 607                 prev= psip_fd, psip_fd= psip_fd->pf_rd_next)
 608         {
 609 again:
 610                 if (!(psip_fd->pf_flags & PFF_PROMISC))
 611                         continue;
 612                 next= psip_fd->pf_rd_next;
 613                 if (prev)
 614                         prev->pf_rd_next= next;
 615                 else
 616                         psip_port->pp_rd_head= next;
 617                 if (!next)
 618                         psip_port->pp_rd_tail= prev;
 619
 620                 assert(psip_fd->pf_flags & PFF_READ_IP);
 621                 psip_fd->pf_flags &= ~PFF_READ_IP;
 622
 623                 buf_size= bf_bufsize(pack);
 624                 if (buf_size <= psip_fd->pf_rd_count)
 625                 {
 626                         psip_port->pp_promisc_head= pack->acc_ext_link;
 627                         result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
 628                                 (size_t)0, pack, FALSE);
 629                         if (result == NW_OK)
 630                                 result= buf_size;
 631                 }
 632                 else
 633                         result= EPACKSIZE;
 634
 635                 result1= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
 636                                 (size_t)result, NULL, FALSE);
 637                 assert(result1 == NW_OK);
 638
 639                 if (psip_port->pp_promisc_head)
 640                 {
 641                         /* Restart from the beginning */
 642                         assert(result == EPACKSIZE);
 643                         psip_fd= psip_port->pp_rd_head;
 644                         prev= NULL;
 645                         goto again;
 646                 }
 647                 break;
 648         }
 649 }
 650
 651 static int psip_setopt(psip_fd, newoptp)
 652 psip_fd_t *psip_fd;
 653 nwio_psipopt_t *newoptp;
 654 {
 655         nwio_psipopt_t oldopt;
 656         unsigned int new_en_flags, new_di_flags, old_en_flags, old_di_flags;
 657         unsigned long new_flags;
 658
 659         oldopt= psip_fd->pf_psipopt;
 660
 661         old_en_flags= oldopt.nwpo_flags & 0xffff;
 662         old_di_flags= (oldopt.nwpo_flags >> 16) & 0xffff;
 663
 664         new_en_flags= newoptp->nwpo_flags & 0xffff;
 665         new_di_flags= (newoptp->nwpo_flags >> 16) & 0xffff;
 666
 667         if (new_en_flags & new_di_flags)
 668                 return EBADMODE;
 669
 670         /* NWUO_LOCADDR_MASK */
 671         if (!((new_en_flags | new_di_flags) & NWPO_PROMISC_MASK))
 672         {
 673                 new_en_flags |= (old_en_flags & NWPO_PROMISC_MASK);
 674                 new_di_flags |= (old_di_flags & NWPO_PROMISC_MASK);
 675         }
 676
 677         new_flags= ((unsigned long)new_di_flags << 16) | new_en_flags;
 678         if ((new_flags & NWPO_EN_PROMISC) &&
 679                 (psip_fd->pf_port->pp_flags & PPF_PROMISC))
 680         {
 681                 printf("psip_setopt: EBUSY for port %d, flags 0x%x\n",
 682                         psip_fd->pf_port - psip_port_table,
 683                         psip_fd->pf_port->pp_flags);
 684                 /* We can support only one at a time. */
 685                 return EBUSY;
 686         }
 687
 688         psip_fd->pf_psipopt= *newoptp;
 689         psip_fd->pf_psipopt.nwpo_flags= new_flags;
 690
 691         return NW_OK;
 692 }
 693
 694 static void check_promisc(psip_port)
 695 psip_port_t *psip_port;
 696 {
 697         int i;
 698         psip_fd_t *psip_fd;
 699         acc_t *acc, *acc_next;
 700
 701         /* Check if the port should still be in promiscuous mode.  Overkill
 702          * at the moment.
 703          */
 704         if (!(psip_port->pp_flags & PPF_PROMISC))
 705                 return;
 706
 707         psip_port->pp_flags &= ~PPF_PROMISC;
 708         for (i= 0, psip_fd= psip_fd_table; i<PSIP_FD_NR; i++, psip_fd++)
 709         {
 710                 if ((psip_fd->pf_flags & (PFF_INUSE|PFF_PROMISC)) !=
 711                         (PFF_INUSE|PFF_PROMISC))
 712                 {
 713                         continue;
 714                 }
 715                 if (psip_fd->pf_port != psip_port)
 716                         continue;
 717                 printf("check_promisc: setting PROMISC for port %d\n",
 718                         psip_port-psip_port_table);
 719                 psip_port->pp_flags |= PPF_PROMISC;
 720                 break;
 721         }
 722         if (!(psip_port->pp_flags & PPF_PROMISC))
 723         {
 724                 /* Delete queued packets. */
 725                 acc= psip_port->pp_promisc_head;
 726                 psip_port->pp_promisc_head= NULL;
 727                 while (acc)
 728                 {
 729                         acc_next= acc->acc_ext_link;
 730                         bf_afree(acc);
 731                         acc= acc_next;
 732                 }
 733         }
 734 }
 735
 736 static void psip_buffree (priority)
 737 int priority;
 738 {
 739         int i;
 740         psip_port_t *psip_port;
 741         acc_t *tmp_acc, *next_acc;
 742
 743         if (priority == PSIP_PRI_EXP_PROMISC)
 744         {
 745                 for (i=0, psip_port= psip_port_table; i<psip_conf_nr;
 746                         i++, psip_port++)
 747                 {
 748                         if (!(psip_port->pp_flags & PPF_CONFIGURED) )
 749                                 continue;
 750                         if (psip_port->pp_promisc_head)
 751                         {
 752                                 tmp_acc= psip_port->pp_promisc_head;
 753                                 while(tmp_acc)
 754                                 {
 755                                         next_acc= tmp_acc->acc_ext_link;
 756                                         bf_afree(tmp_acc);
 757                                         tmp_acc= next_acc;
 758                                 }
 759                                 psip_port->pp_promisc_head= NULL;
 760                         }
 761                 }
 762         }
 763 }
 764
 765 #ifdef BUF_CONSISTENCY_CHECK
 766 static void psip_bufcheck()
 767 {
 768         int i;
 769         psip_port_t *psip_port;
 770         acc_t *tmp_acc;
 771
 772         for (i= 0, psip_port= psip_port_table; i<psip_conf_nr;
 773                 i++, psip_port++)
 774         {
 775                 for (tmp_acc= psip_port->pp_promisc_head; tmp_acc;
 776                         tmp_acc= tmp_acc->acc_ext_link)
 777                 {
 778                         bf_check_acc(tmp_acc);
 779                 }
 780         }
 781 }
 782 #endif
 783
 784 /*
 785 reply_thr_put
 786 */
 787
 788 static void reply_thr_put(psip_fd, reply, for_ioctl)
 789 psip_fd_t *psip_fd;
 790 int reply;
 791 int for_ioctl;
 792 {
 793         int result;
 794
 795         result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd, reply,
 796                 (acc_t *)0, for_ioctl);
 797         assert(result == NW_OK);
 798 }
 799
 800 /*
 801 reply_thr_get
 802 */
 803
 804 static void reply_thr_get(psip_fd, reply, for_ioctl)
 805 psip_fd_t *psip_fd;
 806 int reply;
 807 int for_ioctl;
 808 {
 809         acc_t *result;
 810         result= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd, reply,
 811                 (size_t)0, for_ioctl);
 812         assert (!result);
 813 }
 814
 815
 816 /*
 817  * $PchId: psip.c,v 1.15 2005/06/28 14:19:29 philip Exp $
 818  */