开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
dhcpcCommonLib.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：104k
源码类别：

VxWorks

开发平台：

C/C++

dhcpcCommonLib.c：源码内容
  1. /* dhcpcCommonLib.c - DHCP client interface shared code library */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 02a,26apr02,wap  Update documentation for dhcpcOptionAdd() routine (SPR
  10.                  #73769)
  11. 01z,23apr02,wap  Use BPF_WORDALIGN() when retreiving multiple messages from a
  12.                  BPF buffer (SPR #74215)
  13. 01y,06dec01,wap  Add NPT support
  14. 01x,16nov01,spm  added mod history fix from main branch, ver 01w, base 01v
  15. 01w,15oct01,rae  merge from truestack ver 01z, base 01q (SPR #65264)
  16. 01v,24may01,mil  Bump up dhcp read task stack size to 5000.
  17. 01u,17nov00,spm  added support for BSD Ethernet devices
  18. 01t,16nov00,spm  added required mutual exclusion when sending message
  19. 01s,24oct00,spm  fixed merge from tor3_x branch and updated mod history
  20. 01r,23oct00,niq  merged from version 01w of tor3_x branch (base version 01q);
  21.                  upgrade to BPF replaces tagged frames support
  22. 01q,16mar99,spm  recovered orphaned code from tor1_0_1.sens1_1 (SPR #25770)
  23. 01p,06oct98,spm  fixed copying of parameters with IP address pairs (SPR #22416)
  24. 01o,04dec97,spm  added code review modifications
  25. 01n,06oct97,spm  removed reference to deleted endDriver global; replaced with
  26.                  support for dynamic driver type detection
  27. 01m,30sep97,kbw  fixed minor spelling error in library man page
  28. 01l,02sep97,spm  modified handling of fatal errors - corrected conditions for 
  29.                  disabling network interface and added event hook execution
  30. 01k,26aug97,spm  major overhaul: reorganized code and changed user interface
  31.                  to support multiple leases at runtime
  32. 01j,06aug97,spm  removed parameters linked list to reduce memory required;
  33.                  renamed class field of dhcp_reqspec structure to prevent C++
  34.                  compilation errors (SPR #9079); corrected minor errors in
  35.                  man pages introduced by 01i revision
  36. 01i,30jul97,kbw  fixed man page problems found in beta review
  37. 01h,15jul97,spm  cleaned up man pages
  38. 01g,10jun97,spm  moved length test to prevent buffer overflow and isolated 
  39.                  incoming messages in state machine from input hooks
  40. 01f,02jun97,spm  changed DHCP option tags to prevent name conflicts (SPR #8667)
  41.                  and updated man pages
  42. 01e,06may97,spm  changed memory access to align IP header on four byte boundary
  43. 01d,15apr97,kbw  fixing man page format and wording
  44. 01c,07apr97,spm  added code to use Host Requirements defaults and cleanup 
  45.                  memory on exit, fixed bugs caused by Ethernet trailers, 
  46.                  eliminated potential buffer overruns, rewrote documentation
  47. 01b,29jan97,spm  added END driver support and modified to fit coding standards
  48. 01a,14nov96,spm  created from shared functions of dhcpcLib.c and dhcpcBootLib.c
  49. */
  51. /*
  52. DESCRIPTION
  53. This library contains the shared functions used by the both the run-time
  54. and boot-time portions of the DHCP client.
  56. INCLUDE FILES: dhcpcLib.h
  58. SEE ALSO: dhcpcLib
  59. */
  61. /* includes */
  63. #include "dhcp/copyright_dhcp.h"
  64. #include "vxWorks.h"
  65. #include "wdLib.h"
  66. #include "semLib.h"
  67. #include "intLib.h"
  68. #include "vxLib.h"  /* checksum() declaration */
  69. #include "tickLib.h"  /* tickGet() declaration */
  70. #include "muxLib.h"
  72. #include <stdio.h>
  73. #include <stdlib.h>
  74. #include <unistd.h>
  75. #include <string.h>
  76. #include <errno.h>
  77. #include <signal.h>
  78. #include <fcntl.h>
  79. #include <sys/types.h>
  80. #include <sys/socket.h>
  81. #include <sys/ioctl.h>
  82. #include <net/if.h>
  83. #include <netinet/in.h>
  84. #include <netinet/in_systm.h>
  85. #include <netinet/if_ether.h>
  86. #include <netinet/ip.h>
  87. #include <netinet/udp.h>
  88. #include <arpa/inet.h> 
  90. #include "dhcp/dhcpcCommonLib.h"
  91. #include "dhcp/dhcpcStateLib.h"
  92. #include "dhcp/dhcpc.h"
  93. #include "net/bpf.h"
  94. #include "ipProto.h"
  96. /* defines */
  98. #define _BYTESPERWORD  4  /* Conversion factor for IP header */
  100.      /* Host requirements documents default values. */
  102. #define _HRD_MAX_DGRAM  576     /* Default maximum datagram size. */
  103. #define _HRD_IP_TTL     64      /* Default IP time-to-live (seconds) */
  104. #define _HRD_MTU        576     /* Default interface MTU */
  105. #define _HRD_ROUTER     0xffffffff /* Default router solication */
  106.                                    /* address - 255.255.255.255 */
  107. #define _HRD_ARP_TIME   60      /* Default ARP cache timeout (seconds) */
  108. #define _HRD_TCP_TTL    64      /* Default TCP time-to-live (seconds) */
  109. #define _HRD_TCP_TIME   7200    /* Default TCP keepalive interval (seconds) */
  111. /* globals */
  113. int dhcpcDataSock;  /* Accesses runtime DHCP messages */
  114. BOOL _dhcpcBootFlag = FALSE;  /* Data socket available? (only at runtime) */
  116. int dhcpcReadTaskId;                    /* DHCP message retrieval task */
  117. LEASE_DATA **   dhcpcLeaseList;         /* List of available cookies. */
  118. MESSAGE_DATA *  dhcpcMessageList;       /* Available DHCP messages. */
  120. int dhcpcBufSize;  /* Maximum supported message size */
  122. int dhcpcMaxLeases;  /*
  123.                                  * Set externally when building runtime image
  124.                                  * or to 1 when running boot image.
  125.                                  */
  127. int dhcpcMinLease;  /* Set externally when building image. */
  129. int _dhcpcReadTaskPriority  = 56;      /* Priority level of data retriever */
  130. int _dhcpcReadTaskOptions   = 0;       /* Option settings of data retriever */
  131. int _dhcpcReadTaskStackSize = 5000;    /* Stack size of data retriever */
  133.     /* Berkeley Packet Filter instructions for catching DHCP messages. */
  135. struct bpf_insn dhcpfilter[] = {
  136.   BPF_STMT(BPF_LD+BPF_TYPE,0),                /* Save lltype in accumulator */
  137.   BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, ETHERTYPE_IP, 0, 22),  /* IP packet? */
  139.   /*
  140.    * The remaining statements use the (new) BPF_HLEN alias to avoid any
  141.    * link-layer dependencies. The expected destination port and transaction
  142.    * ID values are altered when necessary by the DHCP routines to match the
  143.    * actual settings.
  144.    */
  146.   BPF_STMT(BPF_LD+BPF_H+BPF_ABS+BPF_HLEN, 6),    /* A <- IP FRAGMENT field */
  147.   BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, 0x1fff, 20, 0),         /* OFFSET == 0 ? */
  149.   BPF_STMT(BPF_LDX+BPF_HLEN, 0),          /* X <- frame data offset */
  150.   BPF_STMT(BPF_LD+BPF_B+BPF_IND, 9),      /* A <- IP_PROTO field */
  151.   BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, IPPROTO_UDP, 0, 17),     /* UDP ? */
  153.   BPF_STMT(BPF_LD+BPF_HLEN, 0),           /* A <- frame data offset */
  154.   BPF_STMT(BPF_LDX+BPF_B+BPF_MSH+BPF_HLEN, 0), /* X <- IPHDR LEN field */
  155.   BPF_STMT(BPF_ALU+BPF_ADD+BPF_X, 0),     /* A <- start of UDP datagram */
  156.   BPF_STMT(BPF_MISC+BPF_TAX, 0),          /* X <- start of UDP datagram */
  158.   BPF_STMT(BPF_LD+BPF_H+BPF_IND, 2),      /* A <- UDP DSTPORT */
  159.   BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 68, 0, 11), /* check DSTPORT */
  161.   BPF_STMT(BPF_LD+BPF_H+BPF_ABS+BPF_HLEN, 2),  /* A <- IP LEN field */
  162.   BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 0, 0, 9),    /* Correct IP length? */
  164.   BPF_STMT(BPF_LD+BPF_H+BPF_IND, 4),      /* A <- UDP LEN field */
  165.   BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, 0, 0, 7),    /* Correct UDP length? */
  167.   BPF_STMT(BPF_LD+BPF_B+BPF_IND, 8),      /* A <- DHCP op field */
  168.   BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, BOOTREPLY, 0, 5),
  169.   BPF_STMT(BPF_LD+BPF_W+BPF_IND, 12),      /* A <- DHCP xid field */
  170.   BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, -1, 0, 3),   /* -1 replaced with real xid */
  171.   BPF_STMT(BPF_LD+BPF_W+BPF_IND, 244),    /* A <- DHCP options */
  172.   BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, 0x63825363, 0, 1),
  173.                                                  /* Matches magic cookie? */
  175.   BPF_STMT(BPF_RET+BPF_K+BPF_HLEN, DFLTDHCPLEN + UDPHL + IPHL),
  176.                                            /*
  177.                                             * ignore data beyond expected
  178.                                             * size (some drivers add padding).
  179.                                             */
  180.   BPF_STMT(BPF_RET+BPF_K, 0)          /* unrecognized message: ignore frame */
  181.   };
  183. struct bpf_program dhcpread = {
  184.     sizeof (dhcpfilter) / sizeof (struct bpf_insn),
  185.     dhcpfilter
  186.     };
  188. RING_ID dhcpcEventRing;  /* Ring buffer of DHCP events */
  189. SEM_ID dhcpcEventSem;  /* DHCP event notification */
  191. /* forward declarations */
  193. UCHAR * dhcpcOptionMerge (UCHAR, UCHAR *, UCHAR *, int);
  194. UCHAR * dhcpcOptCreate (UCHAR, UCHAR *, UCHAR *, int);
  196. void dhcpcRead (void);                   /* Retrieve incoming DHCP messages */
  198. /*******************************************************************************
  199. *
  200. * dhcpcArpSend - transmit an outgoing ARP message
  201. *
  202. * This routine uses the MUX or netif interface to send a frame containing an
  203. * ARP packet independently of the link level type. 
  204. *
  205. * RETURNS: OK, or ERROR if send fails.
  206. *
  207. * ERRNO: N/A
  208. *
  209. * NOMANUAL
  210. *
  211. * INTERNAL
  212. * Ideally, the dhcpSend() routine would handle any link-level frame
  213. * using the registered output routine (ipOutput in the ipProto.c module).
  214. * However, constructing frames with the link-level broadcast address
  215. * requires significant changes to the MUX/END interface and the ipOutput
  216. * routine which are not backward compatible. This routine extracts
  217. * relevant portions of the ipOutput routine so that only the driver
  218. * layer interface is affected.
  219. */
  221. STATUS dhcpcArpSend
  222.     (
  223.     struct ifnet *      pIf,    /* interface for sending message */
  224.     char *              pData,  /* frame containing ARP packet */
  225.     int                 size  /* length of frame, in bytes */
  226.     )
  227.     {
  228.     u_short etype;
  229.     int s;
  230.     struct mbuf * pMbuf;
  231.     IP_DRV_CTRL* pDrvCtrl;
  232.     struct arpcom *ac = (struct arpcom *)pIf;
  233.     struct ether_header *eh;
  235.     BOOL bsdFlag = FALSE;    /* BSD or END network device? */
  237.     pDrvCtrl = (IP_DRV_CTRL *)pIf->pCookie;
  238.     if (pDrvCtrl == NULL)
  239.         bsdFlag = TRUE;         
  240.     else if (pDrvCtrl->pIpCookie == NULL)
  241.         return (ERROR);
  243.     if ((pIf->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
  244.         return (ERROR);
  246.     pMbuf = bcopy_to_mbufs (pData, size, 0, pIf, NONE);
  247.     if (pMbuf == NULL)
  248.         return (ERROR);
  250.     pIf->if_lastchange = tickGet();
  252.     etype = htons (ETHERTYPE_ARP);
  254.     if (bsdFlag)
  255.         {
  256.         /* Build an Ethernet header to the broadcast address. */
  258.         M_PREPEND (pMbuf, sizeof (struct ether_header), M_DONTWAIT);
  259.         if (pMbuf == 0)
  260.             return (ERROR);
  262.         eh = mtod (pMbuf, struct ether_header *);
  264.         pMbuf->mBlkHdr.mFlags |= M_BCAST; /* Always broadcast ARP messages. */
  266.         bcopy((caddr_t)&etype,(caddr_t)&eh->ether_type,
  267.                 sizeof(eh->ether_type));
  268.         bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
  269.               sizeof (etherbroadcastaddr));
  270.         bcopy((caddr_t)ac->ac_enaddr, (caddr_t)eh->ether_shost,
  271.             sizeof(eh->ether_shost));
  272.         } 
  273.     else
  274.         {
  275.         /*
  276.          * Use the MUX interface to build a frame header. We
  277.          * need to handle both END and NPT devices here.
  278.          */
  280.         if (pDrvCtrl->nptFlag)
  281.             {
  282.             if (pIf->if_addrlen)
  283.                 {
  284.                 M_PREPEND(pMbuf, pIf->if_addrlen, M_DONTWAIT);
  285.                 if (pMbuf == NULL)
  286.                     return(ERROR);
  287.                 ((M_BLK_ID)pMbuf)->mBlkPktHdr.rcvif = 0;
  289.                 /* Store the destination address. */
  291.                 bcopy (pDrvCtrl->pDstAddr, pMbuf->m_data, pIf->if_addrlen);
  292.                 }
  294.             /* Save the network protocol type. */
  296.             ((M_BLK_ID)pMbuf)->mBlkHdr.reserved = etype;
  297.             }
  298.         else
  299.             {
  300.             pDrvCtrl->pSrc->m_data = (char *)&ac->ac_enaddr;
  301.             pDrvCtrl->pDst->mBlkHdr.reserved = etype;
  302.             pDrvCtrl->pSrc->mBlkHdr.reserved = etype;
  304.             pMbuf->mBlkHdr.mFlags |= M_BCAST; /* Always broadcast ARP messages. */
  306.             if ((pMbuf = muxLinkHeaderCreate (pDrvCtrl->pIpCookie, pMbuf,
  307.                                               pDrvCtrl->pSrc,
  308.                                               pDrvCtrl->pDst, TRUE)) == NULL)
  309.                 return (ERROR);
  310.             }
  311.         }
  313.     s = splimp();
  315.     /*
  316.      * Queue message on interface, and start output if interface
  317.      * not yet active.
  318.      */
  320.     if (IF_QFULL(&pIf->if_snd))
  321.         {
  322.         IF_DROP(&pIf->if_snd);
  323.         splx(s);
  324.         netMblkClChainFree (pMbuf);
  325.         return (ERROR);
  326.         }
  327.     IF_ENQUEUE(&pIf->if_snd, pMbuf);
  329.     if ((pIf->if_flags & IFF_OACTIVE) == 0)
  330.         (*pIf->if_start)(pIf);
  331.     splx(s);
  332.     pIf->if_obytes += pMbuf->mBlkHdr.mLen;
  333.     if (pMbuf->m_flags & M_MCAST || pMbuf->m_flags & M_BCAST)
  334.         pIf->if_omcasts++;
  336.     return (OK);
  337.     }
  339. /*******************************************************************************
  340. *
  341. * dhcpSend - transmit an outgoing DHCP message
  342. *
  343. * This routine uses the MUX interface to send an IP packet containing a
  344. * DHCP message independently of the link level type. It is derived from
  345. * the ipOutput() routine in the ipProto.c module. It also transmits messages
  346. * for a BSD Ethernet interface.
  347. *
  348. * RETURNS: OK, or ERROR if send fails.
  349. *
  350. * ERRNO: N/A
  351. *
  352. * INTERNAL
  353. * Since the underlying processing performs address resolution, this transmit
  354. * routine is only valid when sending messages to a DHCP participant (such
  355. * as a server or relay agent) with a known IP address. It cannot send
  356. * replies to clients since the hosts will not respond to resolution requests
  357. * for the target IP address if it is not yet assigned.
  358. *
  359. * NOMANUAL
  360. */
  362. STATUS dhcpSend
  363.     (
  364.     struct ifnet *  pIf,    /* interface for sending message */
  365.     struct sockaddr_in *  pDest,  /* destination IP address of message */
  366.     char *  pData,  /* IP packet containing DHCP message */
  367.     int  size,   /* amount of data to send */
  368.     BOOL  broadcastFlag   /* broadcast packet? */
  369.     )
  370.     {
  371.     struct mbuf * pMbuf;
  372.     int result;
  373.     int level;
  375.     pMbuf = bcopy_to_mbufs (pData, size, 0, pIf, NONE);
  376.     if (pMbuf == NULL)
  377.         return (ERROR);
  379.     if (broadcastFlag)
  380.         pMbuf->mBlkHdr.mFlags |= M_BCAST;
  382.     level = splnet ();
  383.     result = pIf->if_output (pIf, pMbuf, (struct sockaddr *)pDest, NULL);
  384.     splx (level);
  386.     if (result)
  387.         return (ERROR);
  389.     return (OK);
  390.     }
  392. /*******************************************************************************
  393. *
  394. * dhcpcRead - handle all incoming DHCP messages
  395. *
  396. * This routine monitors all active BPF devices for new DHCP messages and
  397. * signals the lease monitor task when a valid message arrives. It is the
  398. * entry point for the data retrieval task created during the library
  399. * initialization and should only be called internally.
  400. *
  401. * RETURNS: N/A
  402. *
  403. * ERRNO: N/A
  404. *
  405. * NOMANUAL
  406. */
  408. void dhcpcRead (void)
  409.     {
  410.     STATUS  result;
  412.     EVENT_DATA  newEvent;
  413.     int key;
  415.     char *  pMsgData = NULL;
  417.     BOOL  dataFlag;
  418.     fd_set  readFds;
  419.     int  fileNum = 0;
  420.     int  maxFileNum;
  421.     int  slot = 0;  /* Current buffer for holding messages. */
  422.     int  maxSlot = 10;  /* Matches size of event ring. */
  423.     int  loop;
  424.     int  bufSize = 0;
  425.     struct bpf_hdr *  pMsgHdr;
  426.     int  msglen;
  427.     int  curlen;
  428.     int  totlen;  /* Amount of data in BPF buffer. */
  429.     struct timeval timeout;
  431.     timeout.tv_sec = timeout.tv_usec = 0;
  432.  
  433.     FOREVER
  434.         {
  435.         /*
  436.          * Wait until a message arrives or a new DHCP session is available.
  437.          * The dhcpcInit() routine forces the read task to rebuild the list
  438.          * of active devices by sending an empty message to the selected DHCP
  439.          * client port so that the select routine exits.
  440.          */
  442.         FD_ZERO (&readFds);
  443.         maxFileNum = 0;
  445.         if (!_dhcpcBootFlag)
  446.             {
  447.             /*
  448.              * Runtime DHCP sessions monitor a UDP socket bound to the
  449.              * DHCP port to read and discard messages which were already
  450.              * processed through the Berkeley Packet Filters. This socket
  451.              * also allows the read loop to restart when a new DHCP session
  452.              * begins. The boot time DHCP session is unable to use any
  453.              * sockets since no fully configured devices exist.
  454.              */
  455.             
  456.             FD_SET (dhcpcDataSock, &readFds);
  457.             maxFileNum = dhcpcDataSock;
  458.             }
  460.         /* Create list of active BPF devices for monitoring. */
  462.         for (loop = 0; loop < dhcpcMaxLeases; loop++)
  463.             {
  464.             if (dhcpcLeaseList [loop] != NULL &&
  465.                     dhcpcLeaseList [loop]->initFlag)
  466.                 {
  467.                 fileNum = dhcpcLeaseList [loop]->ifData.bpfDev;
  469.                 FD_SET (fileNum, &readFds);
  471.                 if (fileNum > maxFileNum)
  472.                     maxFileNum = fileNum;
  473.                 }
  474.             }
  476.         /*
  477.          * No BPF devices will be active until a lease session starts
  478.          * which uses an interface without an assigned IP address.
  479.          */
  481.         maxFileNum++;     /* Adjust maximum for select() routine. */
  483.         /*
  484.          * Check for an incoming DHCP message. None may be available
  485.          * if a new session started.
  486.          */
  488.         result = select (maxFileNum, &readFds, NULL, NULL, NULL);
  489.         if (result <= 0)
  490.             continue;
  492.         /*
  493.          * Ignore the message if the current buffer is full. That
  494.          * condition indicates an overflow of the message "ring".
  495.          */
  497.         if (dhcpcMessageList [slot].writeFlag == FALSE)
  498.             continue;
  500.         dhcpcMessageList [slot].writeFlag = FALSE;
  502.         pMsgData = dhcpcMessageList [slot].msgBuffer;
  504.         if (!_dhcpcBootFlag)
  505.             {
  506.             /*
  507.              * For runtime DHCP sessions, read and discard any DHCP
  508.              * messages which reach the socket layer. An (empty)
  509.              * DHCP message is sent to the loopback address when a
  510.              * new session begins. This operation also removes
  511.              * messages which were already handled by the Berkeley
  512.              * Packet Filter, but also reach the socket layer if
  513.              * any device is configured with an IP address. Creating
  514.              * a socket to receive them prevents the transmission of
  515.              * ICMP errors.
  516.              */
  518.             dataFlag = FD_ISSET (dhcpcDataSock, &readFds);
  519.             if (dataFlag)
  520.                 {
  521.                 read (dhcpcDataSock, pMsgData, dhcpcBufSize);
  522.                 dhcpcMessageList [slot].writeFlag = TRUE;
  523.                 continue;
  524.                 }
  525.             }
  527.         /* Read the first available DHCP message. */
  529.         for (loop = 0; loop < dhcpcMaxLeases; loop++)
  530.             {
  531.             if (dhcpcLeaseList [loop]->initFlag)
  532.                 {
  533.                 fileNum = dhcpcLeaseList [loop]->ifData.bpfDev;
  534.                 dataFlag = FD_ISSET (fileNum, &readFds);
  535.                 if (dataFlag)
  536.                     {
  537.                     /*
  538.                      * Any users must read an entire BPF buffer. The size
  539.                      * is set during the initialization for each lease.
  540.                      */
  542.                     bufSize = dhcpcLeaseList [loop]->ifData.bufSize;
  543.                     break;
  544.                     }
  545.                 }
  546.             }
  548.         if (loop == dhcpcMaxLeases)
  549.             {
  550.             /* No DHCP sessions are using the BPF devices. */
  552.             continue;
  553.             }
  554.  
  555.         /*
  556.          * Ignore any read errors. The DHCP protocol is designed to handle
  557.          * any problems with false arrival notifications or invalid messages.
  558.          */
  560.         totlen = read (fileNum, pMsgData, bufSize);
  562.         /* Signal lease monitor for each DHCP message in the BPF buffer. */
  564.         newEvent.source = DHCP_AUTO_EVENT;
  565.         newEvent.type = DHCP_MSG_ARRIVED;
  566.         newEvent.leaseId = dhcpcLeaseList [loop];
  567.         newEvent.slot = slot;
  569.         msglen = curlen = 0;
  570.         pMsgHdr = (struct bpf_hdr *)pMsgData;
  572.         while (curlen < totlen)
  573.             {
  574.             msglen = BPF_WORDALIGN(pMsgHdr->bh_hdrlen + pMsgHdr->bh_caplen);
  575.             curlen += msglen;
  577.             /* Set the pointer to skip the BPF and link level headers. */
  579.             newEvent.pMsg = pMsgData + pMsgHdr->bh_hdrlen +
  580.                                 pMsgHdr->bh_linklen;
  582.             if (curlen < totlen)
  583.                 newEvent.lastFlag = FALSE;
  584.             else
  585.                 newEvent.lastFlag = TRUE;
  587.             /* Lock interrupts to prevent conflicts with timeout thread. */
  589.             key = intLock ();
  590.             rngBufPut (dhcpcEventRing, (char *) &newEvent, sizeof(newEvent));
  591.             intUnlock (key);
  593.             semGive (dhcpcEventSem);
  595.             pMsgData = pMsgData + msglen;
  596.             pMsgHdr = (struct bpf_hdr *)pMsgData;
  597.             }
  599.         /* Advance to next element in message ring. */
  601.         slot = (slot + 1) % maxSlot;
  602.         }
  603.     }
  605. /*******************************************************************************
  606. *
  607. * dhcpcOptionSet - add an option to the option request list
  608. *
  609. * This routine specifies which options the lease indicated by the <pCookie>
  610. * parameter will request from a server.  The <option> parameter specifies an 
  611. * option tag as defined in RFC 2132.  See the dhcp/dhcp.h include file for a
  612. * listing of defined aliases for the available option tags. This routine will
  613. * not accept the following <option> values, which are either used by the
  614. * server for control purposes or only supplied by the client:
  615. *
  616. *     _DHCP_PAD_TAG
  617. *     _DHCP_REQUEST_IPADDR_TAG 
  618. *     _DHCP_LEASE_TIME_TAG  
  619. *     _DHCP_OPT_OVERLOAD_TAG
  620. *     _DHCP_MSGTYPE_TAG
  621. *     _DHCP_SERVER_ID_TAG
  622. *     _DHCP_REQ_LIST_TAG 
  623. *     _DHCP_ERRMSG_TAG 
  624. *     _DHCP_MAXMSGSIZE_TAG
  625. *     _DHCP_CLASS_ID_TAG 
  626. *     _DHCP_CLIENT_ID_TAG 
  627. *     _DHCP_END_TAG
  628. *
  629. * This routine also will not accept <option> values 62 or 63, which are not
  630. * currently defined.
  631. *
  632. * The maximum length of the option field in a DHCP message depends on the
  633. * MTU size of the associated interface and the maximum DHCP message size set
  634. * during the DHCP library initialization. Both the option request list and
  635. * the options sent by the client through the dhcpcOptionAdd() routine share
  636. * that field. Options which exceed the limit will not be stored.
  637. *
  638. * NOTE: The boot program automatically requests all options necessary for
  639. * default target configuration. This routine is only necessary to support
  640. * special circumstances in which additional options are required. Any
  641. * options requested in that case may be retrieved after the runtime image
  642. * has started.
  643. * 
  644. * NOTE: The DHCP specification forbids changing the option request list after
  645. * a lease has been established.  Therefore, this routine must not be used
  646. * after the dhcpcBind() call (in a runtime image) or the dhcpcBootBind() call
  647. * (for a boot image).  Changing the request list at that point could have
  648. * unpredictable results.
  649. *
  650. * NOTE: Options are added directly to outgoing DHCP messages, and numeric
  651. * options (e.g. lease duration time) are expected to be provided in network
  652. * byte order. Care must be taken on little-endian hosts to insure that
  653. * numeric arguments are properly byte-swapped before being passed to this
  654. * routine.
  655. *
  656. * RETURNS: OK if the option was set successfully, or ERROR if the option
  657. * is invalid or storage failed.
  658. *
  659. * ERRNO: S_dhcpcLib_BAD_OPTION, S_dhcpcLib_OPTION_NOT_STORED
  660. *
  661. */
  663. STATUS dhcpcOptionSet
  664.     (
  665.     void *  pCookie,  /* identifier returned by dhcpcInit() */
  666.     int  option /* RFC 2132 tag of desired option */
  667.     )
  668.     {
  669.     LEASE_DATA *   pLeaseData;
  670.     struct dhcp_reqspec *  pReqSpec;
  671.     struct dhcpcOpts *  pOptList;
  673.     int msglen = 0;  /* Length of DHCP message after inserting option */
  675.     /*
  676.      * Use the cookie to access the lease-specific data structures.  For now,
  677.      * just typecast the cookie.  This translation could be replaced with a more
  678.      * sophisticated lookup at some point.
  679.      */
  681.     pLeaseData = (LEASE_DATA *)pCookie;
  682.     pReqSpec = &pLeaseData->leaseReqSpec;
  684.     /* Check for restricted or undefined options. */
  686.     switch (option)
  687.         {
  688.         case _DHCP_PAD_TAG:  /* fall-through */
  689.         case _DHCP_REQUEST_IPADDR_TAG:  /* fall-through */
  690.         case _DHCP_LEASE_TIME_TAG:  /* fall-through */
  691.         case _DHCP_OPT_OVERLOAD_TAG:  /* fall-through */
  692.         case _DHCP_MSGTYPE_TAG:  /* fall-through */
  693.         case _DHCP_SERVER_ID_TAG:  /* fall-through */
  694.         case _DHCP_REQ_LIST_TAG:  /* fall-through */
  695.         case _DHCP_ERRMSG_TAG:  /* fall-through */
  696.         case _DHCP_MAXMSGSIZE_TAG:  /* fall-through */
  697.         case _DHCP_CLASS_ID_TAG:  /* fall-through */
  698.         case _DHCP_CLIENT_ID_TAG:  /* fall-through */
  699.         case _DHCP_END_TAG:
  700.             errno = S_dhcpcLib_BAD_OPTION;
  701.             return (ERROR);
  702.             break;
  703.         default:
  704.             break;
  705.         }
  707.     if (option == 62 || option == 63)
  708.         {
  709.         errno = S_dhcpcLib_BAD_OPTION;
  710.         return (ERROR);
  711.         }
  712.         
  713.     if (option < 0 || option > _DHCP_LAST_OPTION)
  714.         {
  715.         errno = S_dhcpcLib_BAD_OPTION;
  716.         return (ERROR);
  717.         }
  719.     /*
  720.      * Verify that the option won't exceed the MTU size for a message.
  721.      * Start with an initial length equal to the UDP and IP headers and
  722.      * the fixed-length portion of a DHCP message.
  723.      */
  725.     msglen = UDPHL + IPHL + (DFLTDHCPLEN - DFLTOPTLEN);
  727.     /* Include size of existing options and option request list. */
  729.     pOptList = pReqSpec->pOptList;
  731.     if (pOptList)
  732.         msglen += pReqSpec->pOptList->optlen;
  734.     msglen += (pReqSpec->reqlist.len + 1);
  736.     /*
  737.      * Include space for required magic cookie (4 bytes), message
  738.      * type option (3 bytes), maximum message size (4 bytes), and
  739.      * server identifier option (6 bytes).
  740.      */
  742.     msglen += 17;
  744.     /* Include space for required requested IP address option (6 bytes). */
  746.     msglen += 6;
  748.     if (msglen > pReqSpec->maxlen)
  749.         {
  750.         /*
  751.          * Option field is full.  New option would either exceed MTU size
  752.          * or overflow the transmit buffer.
  753.          */
  755.         errno = S_dhcpcLib_OPTION_NOT_STORED;
  756.         return (ERROR);
  757.         }
  759.     pReqSpec->reqlist.list [pReqSpec->reqlist.len++] = option;
  761.     return (OK);
  762.     }
  764. /*******************************************************************************
  765. *
  766. * dhcpcOptionAdd - add an option to the client messages
  767. *
  768. * This routine inserts option tags and associated values into the body of
  769. * all outgoing messages for the lease indicated by the <pCookie> parameter.
  770. * Each lease can accept option data up to the MTU size of the underlying
  771. * interface, minus the link-level header size and the additional 283 bytes
  772. * required for a minimum DHCP message (including mandatory options).
  773. *
  774. * The <option> parameter specifies an option tag defined in RFC 2132. See
  775. * the dhcp/dhcp.h include file for a listing of defined aliases for the
  776. * available option tags. This routine will not accept the following <option>
  777. * values, which are used for control purposes and cannot be included
  778. * arbitrarily:
  779. *
  780. *     _DHCP_PAD_TAG
  781. *     _DHCP_OPT_OVERLOAD_TAG
  782. *     _DHCP_MSGTYPE_TAG
  783. *     _DHCP_SERVER_ID_TAG
  784. *     _DHCP_MAXMSGSIZE_TAG
  785. *     _DHCP_END_TAG
  786. *
  787. * This routine also will not accept <option> values 62 or 63, which are not
  788. * currently defined.
  789. *
  790. * The <length> parameter indicates the number of bytes in the option body
  791. * provided by the <pData> parameter. 
  792. *
  793. * The maximum length of the option field in a DHCP message depends on the
  794. * MTU size of the associated interface and the maximum DHCP message size set
  795. * during the DHCP library initialization. These option settings share that
  796. * field with any option request list created through the dhcpcOptionSet()
  797. * routine. Options which exceed the limit will not be stored.
  798. *
  799. * Each call to this routine with the same <option> value usually replaces
  800. * the value of the existing option, if any. However, the routine will append
  801. * the new data for the <option> values which contain variable length lists,
  802. * corresponding to tags 3-11, 21, 25, 33, 41-45, 48-49, 55, 65, and 68-76.
  803. *
  804. * WARNING: The _DHCP_REQ_LIST_TAG <option> value (55) will replace
  805. * any existing list created with the dhcpcOptionSet() routine.
  806. *
  807. * RETURNS: OK if the option was inserted successfully, or ERROR if the option
  808. * is invalid or storage failed.
  809. *
  810. * ERRNO: S_dhcpcLib_BAD_OPTION, S_dhcpcLib_OPTION_NOT_STORED
  811. *
  812. */
  814. STATUS dhcpcOptionAdd
  815.     (
  816.     void *  pCookie,  /* identifier returned by dhcpcInit() */
  817.     UCHAR  option,  /* RFC 2132 tag of desired option */
  818.     int  length,  /* length of option data */
  819.     UCHAR *  pData  /* option data */
  820.     )
  821.     {
  822.     LEASE_DATA *                pLeaseData;
  823.     struct dhcp_reqspec *       pReqSpec;
  824.     char *  pDest;
  825.     struct dhcpcOpts *  pOptList;
  827.     int msglen = 0;  /* Length of DHCP message after inserting option */
  829.     /*
  830.      * Use the cookie to access the lease-specific data structures.  For now,
  831.      * just typecast the cookie.  This translation could be replaced with a more
  832.      * sophisticated lookup at some point.
  833.      */
  835.     pLeaseData = (LEASE_DATA *)pCookie;
  836.     pReqSpec = &pLeaseData->leaseReqSpec;
  838.     /* Check for restricted or invalid options. */
  840.     switch (option)
  841.         {
  842.         case _DHCP_PAD_TAG:             /* fall-through */
  843.         case _DHCP_OPT_OVERLOAD_TAG:    /* fall-through */
  844.         case _DHCP_MSGTYPE_TAG:         /* fall-through */
  845.         case _DHCP_SERVER_ID_TAG:       /* fall-through */
  846.         case _DHCP_MAXMSGSIZE_TAG:      /* fall-through */
  847.         case _DHCP_END_TAG:
  848.             errno = S_dhcpcLib_BAD_OPTION;
  849.             return (ERROR);
  850.             break;
  851.         default:
  852.             break;
  853.         }
  855.     if (option == 62 || option == 63)
  856.         {
  857.         errno = S_dhcpcLib_BAD_OPTION;
  858.         return (ERROR);
  859.         }
  860.         
  861.     /*
  862.      * Verify that the option won't exceed the MTU size for a message.
  863.      * Start with an initial length equal to the UDP and IP headers and
  864.      * the fixed-length portion of a DHCP message.
  865.      */
  867.     msglen = UDPHL + IPHL + (DFLTDHCPLEN - DFLTOPTLEN);
  869.     /* Include size of existing options and option request list. */
  871.     pOptList = pReqSpec->pOptList;
  873.     if (pOptList)
  874.         msglen += pReqSpec->pOptList->optlen;
  876.     if (option == _DHCP_REQ_LIST_TAG)    /* Replacing request list? */
  877.         msglen -= pReqSpec->reqlist.len;
  878.     else
  879.         msglen += pReqSpec->reqlist.len;
  881.     /*
  882.      * Include space for required magic cookie (4 bytes), message
  883.      * type option (3 bytes), maximum message size (4 bytes), and
  884.      * server identifier option (6 bytes).
  885.      */
  887.     msglen += 17;
  889.     /* Include space for required requested IP address option (6 bytes). */
  891.     msglen += 6;
  893.     /* Add size of any other option (don't double-count IP address). */
  895.     if (option != _DHCP_REQUEST_IPADDR_TAG)
  896.         msglen += length + 2;    /* +2 includes tag and length values */
  898.     if (msglen > dhcpcBufSize)
  899.         {
  900.         /* Option field is full.  New option would overflow transmit buffer. */
  902.         errno = S_dhcpcLib_OPTION_NOT_STORED;
  903.         return (ERROR);
  904.         }
  906.     if (msglen > pReqSpec->maxlen)
  907.         {
  908.         /*
  909.          * Option field is full.  New option would either exceed MTU size
  910.          * or overflow the transmit buffer.
  911.          */
  913.         errno = S_dhcpcLib_OPTION_NOT_STORED;
  914.         return (ERROR);
  915.         }
  917.     if (pData == NULL)
  918.         {
  919.         errno = S_dhcpcLib_BAD_OPTION;
  920.         return (ERROR);
  921.         }
  923.     /* Validate the length of each option. */
  925.     switch (option)
  926.         {
  927.         /* 1 byte values */
  929.         case _DHCP_IP_FORWARD_TAG:  /* Option Tag 19 */
  930.         case _DHCP_NONLOCAL_SRCROUTE_TAG:  /* Option Tag 20 */
  931.         case _DHCP_DEFAULT_IP_TTL_TAG:  /* Option Tag 23 */
  932.         case _DHCP_ALL_SUBNET_LOCAL_TAG:  /* Option Tag 27 */
  933.         case _DHCP_MASK_DISCOVER_TAG:  /* Option Tag 29 */
  934.         case _DHCP_MASK_SUPPLIER_TAG:  /* Option Tag 30 */
  935.         case _DHCP_ROUTER_DISCOVER_TAG:  /* Option Tag 31 */
  936.         case _DHCP_TRAILER_TAG:  /* Option Tag 34 */
  937.         case _DHCP_ETHER_ENCAP_TAG:  /* Option Tag 36 */
  938.         case _DHCP_DEFAULT_TCP_TTL_TAG:  /* Option Tag 37 */
  939.         case _DHCP_KEEPALIVE_GARBAGE_TAG:  /* Option Tag 39 */
  940.         case _DHCP_NB_NODETYPE_TAG:  /* Option Tag 46 */
  941.             if (length != 1)
  942.                 {
  943.                 errno = S_dhcpcLib_BAD_OPTION;
  944.                 return (ERROR);
  945.                 }
  946.             break;
  948.         /* 2 byte values */
  950.         case _DHCP_BOOTSIZE_TAG:  /* Option Tag 13 */
  951.         case _DHCP_MAX_DGRAM_SIZE_TAG:  /* Option Tag 22 */
  952.         case _DHCP_IF_MTU_TAG:  /* Option Tag 26 */
  953.             if (length != 2)
  954.                 {
  955.                 errno = S_dhcpcLib_BAD_OPTION;
  956.                 return (ERROR);
  957.                 }
  958.             break;
  960.         /* 4 byte values */
  962.         case _DHCP_SUBNET_MASK_TAG:  /* Option Tag 1 */
  963.         case _DHCP_TIME_OFFSET_TAG:  /* Option Tag 2 */
  964.         case _DHCP_SWAP_SERVER_TAG:  /* Option Tag 16 */
  965.         case _DHCP_MTU_AGING_TIMEOUT_TAG:  /* Option Tag 24 */
  966.         case _DHCP_BRDCAST_ADDR_TAG:  /* Option Tag 28 */
  967.         case _DHCP_ROUTER_SOLICIT_TAG:  /* Option Tag 32 */
  968.         case _DHCP_ARP_CACHE_TIMEOUT_TAG:  /* Option Tag 35 */
  969.         case _DHCP_KEEPALIVE_INTERVAL_TAG:  /* Option Tag 38 */
  970.         case _DHCP_REQUEST_IPADDR_TAG:  /* Option Tag 50 */
  971.         case _DHCP_LEASE_TIME_TAG:  /* Option Tag 51 */
  972.         case _DHCP_T1_TAG:  /* Option Tag 58 */
  973.         case _DHCP_T2_TAG:  /* Option Tag 59 */
  974.             if (length != 4)
  975.                 {
  976.                 errno = S_dhcpcLib_BAD_OPTION;
  977.                 return (ERROR);
  978.                 }
  979.             break;
  981.         /* Table entries (2 bytes each) */
  983.         case _DHCP_MTU_PLATEAU_TABLE_TAG:  /* Option Tag 25 */
  984.             if (length % 2)
  985.                 {
  986.                 errno = S_dhcpcLib_BAD_OPTION;
  987.                 return (ERROR);
  988.                 }
  989.             break;
  991.         /* Address values (4 bytes each) */
  993.         case _DHCP_ROUTER_TAG:  /* Option Tag 3 */
  994.         case _DHCP_TIME_SERVER_TAG:  /* Option Tag 4 */
  995.         case _DHCP_NAME_SERVER_TAG:  /* Option Tag 5 */
  996.         case _DHCP_DNS_SERVER_TAG:  /* Option Tag 6 */
  997.         case _DHCP_LOG_SERVER_TAG:  /* Option Tag 7 */
  998.         case _DHCP_COOKIE_SERVER_TAG:  /* Option Tag 8 */
  999.         case _DHCP_LPR_SERVER_TAG:  /* Option Tag 9 */
  1000.         case _DHCP_IMPRESS_SERVER_TAG:  /* Option Tag 10 */
  1001.         case _DHCP_RLS_SERVER_TAG:  /* Option Tag 11 */
  1002.         case _DHCP_NIS_SERVER_TAG:  /* Option Tag 41 */
  1003.         case _DHCP_NTP_SERVER_TAG:  /* Option Tag 42 */
  1004.         case _DHCP_NBN_SERVER_TAG:  /* Option Tag 44 */
  1005.         case _DHCP_NBDD_SERVER_TAG:  /* Option Tag 45 */
  1006.         case _DHCP_XFONT_SERVER_TAG:  /* Option Tag 48 */
  1007.         case _DHCP_XDISPLAY_MANAGER_TAG:  /* Option Tag 49 */
  1008.         case _DHCP_NISP_SERVER_TAG:  /* Option Tag 65 */
  1009.         case _DHCP_MOBILEIP_HA_TAG:  /* Option Tag 68 */
  1010.         case _DHCP_SMTP_SERVER_TAG:  /* Option Tag 69 */
  1011.         case _DHCP_POP3_SERVER_TAG:  /* Option Tag 70 */
  1012.         case _DHCP_NNTP_SERVER_TAG:  /* Option Tag 71 */
  1013.         case _DHCP_DFLT_WWW_SERVER_TAG:  /* Option Tag 72 */
  1014.         case _DHCP_DFLT_FINGER_SERVER_TAG:  /* Option Tag 73 */
  1015.         case _DHCP_DFLT_IRC_SERVER_TAG:   /* Option Tag 74 */
  1016.         case _DHCP_STREETTALK_SERVER_TAG:   /* Option Tag 75 */
  1017.         case _DHCP_STDA_SERVER_TAG:  /* Option Tag 76 */
  1018.             if (length % 4)
  1019.                 {
  1020.                 errno = S_dhcpcLib_BAD_OPTION;
  1021.                 return (ERROR);
  1022.                 }
  1023.             break;
  1025.         /* Address pairs or address/mask values (8 bytes each). */
  1027.         case _DHCP_POLICY_FILTER_TAG:  /* Option Tag 21 */
  1028.         case _DHCP_STATIC_ROUTE_TAG:  /* Option Tag 33 */
  1029.             if (length % 8)
  1030.                 {
  1031.                 errno = S_dhcpcLib_BAD_OPTION;
  1032.                 return (ERROR);
  1033.                 }
  1034.             break;
  1036.         /* Variable-length values */
  1038.         case _DHCP_HOSTNAME_TAG:  /* Option Tag 12 */
  1039.         case _DHCP_MERIT_DUMP_TAG:  /* Option Tag 14 */
  1040.         case _DHCP_DNS_DOMAIN_TAG:  /* Option Tag 15 */
  1041.         case _DHCP_ROOT_PATH_TAG:  /* Option Tag 17 */
  1042.         case _DHCP_EXTENSIONS_PATH_TAG:  /* Option Tag 18 */
  1043.         case _DHCP_NIS_DOMAIN_TAG:  /* Option Tag 40 */
  1044.         case _DHCP_VENDOR_SPEC_TAG:  /* Option Tag 43 */
  1045.         case _DHCP_NB_SCOPE_TAG:  /* Option Tag 47 */
  1046.         case _DHCP_REQ_LIST_TAG:  /* Option Tag 55 */
  1047.         case _DHCP_ERRMSG_TAG:  /* Option Tag 56 */
  1048.         case _DHCP_CLASS_ID_TAG:  /* Option Tag 60 */
  1049.         case _DHCP_CLIENT_ID_TAG:  /* Option Tag 61 */
  1050.         case _DHCP_NISP_DOMAIN_TAG:  /* Option Tag 64 */
  1051.         case _DHCP_TFTP_SERVERNAME_TAG:  /* Option Tag 66 */
  1052.         case _DHCP_BOOTFILE_TAG:  /* Option Tag 67 */
  1053.             if (length < 1 || length > _DHCP_MAX_OPTLEN)
  1054.                 {
  1055.                 errno = S_dhcpcLib_BAD_OPTION;
  1056.                 return (ERROR);
  1057.                 }
  1058.             break;
  1059.         }
  1061.     /* Store the option body in the space provided. */
  1063.     if (pOptList == NULL)
  1064.         {
  1065.         pOptList = malloc (sizeof (struct dhcpcOpts));
  1066.         if (pOptList == NULL)
  1067.             {
  1068.             errno = S_dhcpcLib_OPTION_NOT_STORED;
  1069.             return (ERROR);
  1070.             }
  1071.         bzero ( (char *)pOptList, sizeof (struct dhcpcOpts));
  1072.         pReqSpec->pOptList = pOptList;
  1073.         }
  1075.     switch (option)
  1076.         {
  1077.         /* 1 byte values */
  1079.         case _DHCP_IP_FORWARD_TAG:  /* Option Tag 19 */
  1080.             pOptList->tag19 = *pData;
  1081.             break;    
  1082.         case _DHCP_NONLOCAL_SRCROUTE_TAG:  /* Option Tag 20 */
  1083.             pOptList->tag20 = *pData;
  1084.             break;
  1085.         case _DHCP_DEFAULT_IP_TTL_TAG:  /* Option Tag 23 */
  1086.             pOptList->tag23 = *pData;
  1087.             break;
  1088.         case _DHCP_ALL_SUBNET_LOCAL_TAG:  /* Option Tag 27 */
  1089.             pOptList->tag27 = *pData;
  1090.             break;
  1091.         case _DHCP_MASK_DISCOVER_TAG:  /* Option Tag 29 */
  1092.             pOptList->tag29 = *pData;
  1093.             break;
  1094.         case _DHCP_MASK_SUPPLIER_TAG:  /* Option Tag 30 */
  1095.             pOptList->tag30 = *pData;
  1096.             break;
  1097.         case _DHCP_ROUTER_DISCOVER_TAG:  /* Option Tag 31 */
  1098.             pOptList->tag31 = *pData;
  1099.             break;
  1100.         case _DHCP_TRAILER_TAG:  /* Option Tag 34 */
  1101.             pOptList->tag34 = *pData;
  1102.             break;
  1103.         case _DHCP_ETHER_ENCAP_TAG:  /* Option Tag 36 */
  1104.             pOptList->tag36 = *pData;
  1105.             break;
  1106.         case _DHCP_DEFAULT_TCP_TTL_TAG:  /* Option Tag 37 */
  1107.             pOptList->tag37 = *pData;
  1108.             break;
  1109.         case _DHCP_KEEPALIVE_GARBAGE_TAG:  /* Option Tag 39 */
  1110.             pOptList->tag39 = *pData;
  1111.             break;
  1112.         case _DHCP_NB_NODETYPE_TAG:  /* Option Tag 46 */
  1113.             pOptList->tag46 = *pData;
  1114.             break;
  1116.         /* 2 byte values */
  1118.         case _DHCP_BOOTSIZE_TAG:  /* Option Tag 13 */
  1119.             bcopy (pData, (char *)&pOptList->tag13, sizeof (USHORT));
  1120.             break;
  1121.         case _DHCP_MAX_DGRAM_SIZE_TAG:  /* Option Tag 22 */
  1122.             bcopy (pData, (char *)&pOptList->tag22, sizeof (USHORT));
  1123.             break;
  1124.         case _DHCP_IF_MTU_TAG:  /* Option Tag 26 */
  1125.             bcopy (pData, (char *)&pOptList->tag26, sizeof (USHORT));
  1126.             break;
  1128.         /* 4 byte values */
  1130.         case _DHCP_SUBNET_MASK_TAG:  /* Option Tag 1 */
  1131.             bcopy (pData, (char *)&pOptList->tag1, sizeof (ULONG));
  1132.             break;
  1133.         case _DHCP_TIME_OFFSET_TAG:  /* Option Tag 2 */
  1134.             bcopy (pData, (char *)&pOptList->tag2, sizeof (long));
  1135.             break;
  1136.         case _DHCP_SWAP_SERVER_TAG:  /* Option Tag 16 */
  1137.             bcopy (pData, (char *)&pOptList->tag16, sizeof (ULONG));
  1138.             break;
  1139.         case _DHCP_MTU_AGING_TIMEOUT_TAG:  /* Option Tag 24 */
  1140.             bcopy (pData, (char *)&pOptList->tag24, sizeof (ULONG));
  1141.             break;
  1142.         case _DHCP_BRDCAST_ADDR_TAG:  /* Option Tag 28 */
  1143.             bcopy (pData, (char *)&pOptList->tag28, sizeof (ULONG));
  1144.             break;
  1145.         case _DHCP_ROUTER_SOLICIT_TAG:  /* Option Tag 32 */
  1146.             bcopy (pData, (char *)&pOptList->tag32, sizeof (ULONG));
  1147.             break;
  1148.         case _DHCP_ARP_CACHE_TIMEOUT_TAG:  /* Option Tag 35 */
  1149.             bcopy (pData, (char *)&pOptList->tag35, sizeof (ULONG));
  1150.             break;
  1151.         case _DHCP_KEEPALIVE_INTERVAL_TAG:  /* Option Tag 38 */
  1152.             bcopy (pData, (char *)&pOptList->tag38, sizeof (ULONG));
  1153.             break;
  1154.         case _DHCP_REQUEST_IPADDR_TAG:  /* Option Tag 50 */
  1155.             /*
  1156.              * This option is stored separately since it is not
  1157.              * always included in the client's initial message.
  1158.              */
  1160.             bcopy (pData, (char *)&pReqSpec->ipaddr.s_addr, sizeof (ULONG));
  1161.             break;
  1162.         case _DHCP_LEASE_TIME_TAG:  /* Option Tag 51 */
  1163.             bcopy (pData, (char *)&pOptList->tag51, sizeof (ULONG));
  1164.             break;
  1165.         case _DHCP_T1_TAG:  /* Option Tag 58 */
  1166.             bcopy (pData, (char *)&pOptList->tag58, sizeof (ULONG));
  1167.             break;
  1168.         case _DHCP_T2_TAG:  /* Option Tag 59 */
  1169.             bcopy (pData, (char *)&pOptList->tag59, sizeof (ULONG));
  1170.             break;
  1172.         /*
  1173.          * Variable-length lists. Add new entry or merge.
  1174.          * Store tag value and length before option body.
  1175.          */
  1177.         case _DHCP_MTU_PLATEAU_TABLE_TAG:  /* Option Tag 25 */
  1178.             pDest = dhcpcOptionMerge (option, pOptList->pTag25, pData, length);
  1179.             if (pDest == NULL)
  1180.                 {
  1181.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1182.                 return (ERROR);
  1183.                 }
  1184.             else
  1185.                 pOptList->pTag25 = pDest;
  1186.             break;
  1188.         case _DHCP_ROUTER_TAG:  /* Option Tag 3 */
  1189.             pDest = dhcpcOptionMerge (option, pOptList->pTag3, pData, length);
  1190.             if (pDest == NULL)
  1191.                 {
  1192.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1193.                 return (ERROR);
  1194.                 }
  1195.             else
  1196.                 pOptList->pTag3 = pDest;
  1197.             break;
  1198.         case _DHCP_TIME_SERVER_TAG:  /* Option Tag 4 */
  1199.             pDest = dhcpcOptionMerge (option, pOptList->pTag4, pData, length);
  1200.             if (pDest == NULL)
  1201.                 {
  1202.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1203.                 return (ERROR);
  1204.                 }
  1205.             else
  1206.                 pOptList->pTag4 = pDest;
  1207.             break;
  1208.         case _DHCP_NAME_SERVER_TAG:  /* Option Tag 5 */
  1209.             pDest = dhcpcOptionMerge (option, pOptList->pTag5, pData, length);
  1210.             if (pDest == NULL)
  1211.                 {
  1212.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1213.                 return (ERROR);
  1214.                 }
  1215.             else
  1216.                 pOptList->pTag5 = pDest;
  1217.             break;
  1218.         case _DHCP_DNS_SERVER_TAG:  /* Option Tag 6 */
  1219.             pDest = dhcpcOptionMerge (option, pOptList->pTag6, pData, length);
  1220.             if (pDest == NULL)
  1221.                 {
  1222.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1223.                 return (ERROR);
  1224.                 }
  1225.             else
  1226.                 pOptList->pTag6 = pDest;
  1227.             break;
  1228.         case _DHCP_LOG_SERVER_TAG:  /* Option Tag 7 */
  1229.             pDest = dhcpcOptionMerge (option, pOptList->pTag7, pData, length);
  1230.             if (pDest == NULL)
  1231.                 {
  1232.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1233.                 return (ERROR);
  1234.                 }
  1235.             else
  1236.                 pOptList->pTag7 = pDest;
  1237.             break;
  1238.         case _DHCP_COOKIE_SERVER_TAG:  /* Option Tag 8 */
  1239.             pDest = dhcpcOptionMerge (option, pOptList->pTag8, pData, length);
  1240.             if (pDest == NULL)
  1241.                 {
  1242.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1243.                 return (ERROR);
  1244.                 }
  1245.             else
  1246.                 pOptList->pTag8 = pDest;
  1247.             break;
  1248.         case _DHCP_LPR_SERVER_TAG:  /* Option Tag 9 */
  1249.             pDest = dhcpcOptionMerge (option, pOptList->pTag9, pData, length);
  1250.             if (pDest == NULL)
  1251.                 {
  1252.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1253.                 return (ERROR);
  1254.                 }
  1255.             else
  1256.                 pOptList->pTag9 = pDest;
  1257.             break;
  1258.         case _DHCP_IMPRESS_SERVER_TAG:  /* Option Tag 10 */
  1259.             pDest = dhcpcOptionMerge (option, pOptList->pTag10, pData, length);
  1260.             if (pDest == NULL)
  1261.                 {
  1262.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1263.                 return (ERROR);
  1264.                 }
  1265.             else
  1266.                 pOptList->pTag10 = pDest;
  1267.             break;
  1268.         case _DHCP_RLS_SERVER_TAG:  /* Option Tag 11 */
  1269.             pDest = dhcpcOptionMerge (option, pOptList->pTag11, pData, length);
  1270.             if (pDest == NULL)
  1271.                 {
  1272.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1273.                 return (ERROR);
  1274.                 }
  1275.             else
  1276.                 pOptList->pTag11 = pDest;
  1277.             break;
  1278.         case _DHCP_NIS_SERVER_TAG:  /* Option Tag 41 */
  1279.             pDest = dhcpcOptionMerge (option, pOptList->pTag41, pData, length);
  1280.             if (pDest == NULL)
  1281.                 {
  1282.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1283.                 return (ERROR);
  1284.                 }
  1285.             else
  1286.                 pOptList->pTag41 = pDest;
  1287.             break;
  1288.         case _DHCP_NTP_SERVER_TAG:  /* Option Tag 42 */
  1289.             pDest = dhcpcOptionMerge (option, pOptList->pTag42, pData, length);
  1290.             if (pDest == NULL)
  1291.                 {
  1292.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1293.                 return (ERROR);
  1294.                 }
  1295.             else
  1296.                 pOptList->pTag42 = pDest;
  1297.             break;
  1298.         case _DHCP_NBN_SERVER_TAG:  /* Option Tag 44 */
  1299.             pDest = dhcpcOptionMerge (option, pOptList->pTag44, pData, length);
  1300.             if (pDest == NULL)
  1301.                 {
  1302.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1303.                 return (ERROR);
  1304.                 }
  1305.             else
  1306.                 pOptList->pTag44 = pDest;
  1307.             break;
  1308.         case _DHCP_NBDD_SERVER_TAG:  /* Option Tag 45 */
  1309.             pDest = dhcpcOptionMerge (option, pOptList->pTag45, pData, length);
  1310.             if (pDest == NULL)
  1311.                 {
  1312.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1313.                 return (ERROR);
  1314.                 }
  1315.             else
  1316.                 pOptList->pTag45 = pDest;
  1317.             break;
  1318.         case _DHCP_XFONT_SERVER_TAG:  /* Option Tag 48 */
  1319.             pDest = dhcpcOptionMerge (option, pOptList->pTag48, pData, length);
  1320.             if (pDest == NULL)
  1321.                 {
  1322.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1323.                 return (ERROR);
  1324.                 }
  1325.             else
  1326.                 pOptList->pTag48 = pDest;
  1327.             break;
  1328.         case _DHCP_XDISPLAY_MANAGER_TAG:  /* Option Tag 49 */
  1329.             pDest = dhcpcOptionMerge (option, pOptList->pTag49, pData, length);
  1330.             if (pDest == NULL)
  1331.                 {
  1332.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1333.                 return (ERROR);
  1334.                 }
  1335.             else
  1336.                 pOptList->pTag49 = pDest;
  1337.             break;
  1338.         case _DHCP_NISP_SERVER_TAG:  /* Option Tag 65 */
  1339.             pDest = dhcpcOptionMerge (option, pOptList->pTag65, pData, length);
  1340.             if (pDest == NULL)
  1341.                 {
  1342.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1343.                 return (ERROR);
  1344.                 }
  1345.             else
  1346.                 pOptList->pTag65 = pDest;
  1347.             break;
  1348.         case _DHCP_MOBILEIP_HA_TAG:  /* Option Tag 68 */
  1349.             pDest = dhcpcOptionMerge (option, pOptList->pTag68, pData, length);
  1350.             if (pDest == NULL)
  1351.                 {
  1352.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1353.                 return (ERROR);
  1354.                 }
  1355.             else
  1356.                 pOptList->pTag68 = pDest;
  1357.             break;
  1358.         case _DHCP_SMTP_SERVER_TAG:  /* Option Tag 69 */
  1359.             pDest = dhcpcOptionMerge (option, pOptList->pTag69, pData, length);
  1360.             if (pDest == NULL)
  1361.                 {
  1362.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1363.                 return (ERROR);
  1364.                 }
  1365.             else
  1366.                 pOptList->pTag69 = pDest;
  1367.             break;
  1368.         case _DHCP_POP3_SERVER_TAG:  /* Option Tag 70 */
  1369.             pDest = dhcpcOptionMerge (option, pOptList->pTag70, pData, length);
  1370.             if (pDest == NULL)
  1371.                 {
  1372.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1373.                 return (ERROR);
  1374.                 }
  1375.             else
  1376.                 pOptList->pTag70 = pDest;
  1377.             break;
  1378.         case _DHCP_NNTP_SERVER_TAG:  /* Option Tag 71 */
  1379.             pDest = dhcpcOptionMerge (option, pOptList->pTag71, pData, length);
  1380.             if (pDest == NULL)
  1381.                 {
  1382.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1383.                 return (ERROR);
  1384.                 }
  1385.             else
  1386.                 pOptList->pTag71 = pDest;
  1387.             break;
  1388.         case _DHCP_DFLT_WWW_SERVER_TAG:  /* Option Tag 72 */
  1389.             pDest = dhcpcOptionMerge (option, pOptList->pTag72, pData, length);
  1390.             if (pDest == NULL)
  1391.                 {
  1392.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1393.                 return (ERROR);
  1394.                 }
  1395.             else
  1396.                 pOptList->pTag72 = pDest;
  1397.             break;
  1398.         case _DHCP_DFLT_FINGER_SERVER_TAG:  /* Option Tag 73 */
  1399.             pDest = dhcpcOptionMerge (option, pOptList->pTag73, pData, length);
  1400.             if (pDest == NULL)
  1401.                 {
  1402.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1403.                 return (ERROR);
  1404.                 }
  1405.             else
  1406.                 pOptList->pTag73 = pDest;
  1407.             break;
  1408.         case _DHCP_DFLT_IRC_SERVER_TAG:   /* Option Tag 74 */
  1409.             pDest = dhcpcOptionMerge (option, pOptList->pTag74, pData, length);
  1410.             if (pDest == NULL)
  1411.                 {
  1412.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1413.                 return (ERROR);
  1414.                 }
  1415.             else
  1416.                 pOptList->pTag74 = pDest;
  1417.             break;
  1418.         case _DHCP_STREETTALK_SERVER_TAG:   /* Option Tag 75 */
  1419.             pDest = dhcpcOptionMerge (option, pOptList->pTag75, pData, length);
  1420.             if (pDest == NULL)
  1421.                 {
  1422.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1423.                 return (ERROR);
  1424.                 }
  1425.             else
  1426.                 pOptList->pTag75 = pDest;
  1427.             break;
  1428.         case _DHCP_STDA_SERVER_TAG:  /* Option Tag 76 */
  1429.             pDest = dhcpcOptionMerge (option, pOptList->pTag76, pData, length);
  1430.             if (pDest == NULL)
  1431.                 {
  1432.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1433.                 return (ERROR);
  1434.                 }
  1435.             else
  1436.                 pOptList->pTag76 = pDest;
  1437.             break;
  1438.         case _DHCP_POLICY_FILTER_TAG:  /* Option Tag 21 */
  1439.             pDest = dhcpcOptionMerge (option, pOptList->pTag21, pData, length);
  1440.             if (pDest == NULL)
  1441.                 {
  1442.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1443.                 return (ERROR);
  1444.                 }
  1445.             else
  1446.                 pOptList->pTag21 = pDest;
  1447.             break;
  1448.         case _DHCP_STATIC_ROUTE_TAG:  /* Option Tag 33 */
  1449.             pDest = dhcpcOptionMerge (option, pOptList->pTag33, pData, length);
  1450.             if (pDest == NULL)
  1451.                 {
  1452.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1453.                 return (ERROR);
  1454.                 }
  1455.             else
  1456.                 pOptList->pTag33 = pDest;
  1457.             break;
  1458.         case _DHCP_VENDOR_SPEC_TAG:  /* Option Tag 43 */
  1459.             pDest = dhcpcOptionMerge (option, pOptList->pTag43, pData, length);
  1460.             if (pDest == NULL)
  1461.                 {
  1462.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1463.                 return (ERROR);
  1464.                 }
  1465.             else
  1466.                 pOptList->pTag43 = pDest;
  1467.             break;
  1468.         case _DHCP_REQ_LIST_TAG:  /* Option Tag 55 */
  1469.             pDest = dhcpcOptionMerge (option, pOptList->pTag55, pData, length);
  1470.             if (pDest == NULL)
  1471.                 {
  1472.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1473.                 return (ERROR);
  1474.                 }
  1475.             else
  1476.                 {
  1477.                 /* Add new list. Ignore dhcpcOptionSet() routine results. */
  1479.                 pReqSpec->reqlist.len = 0;
  1480.                 pOptList->pTag55 = pDest;
  1481.                 }
  1482.             break;
  1484.         /*
  1485.          * Variable-length values. Add new entry or replace existing one.
  1486.          * Store tag value and length before option body.
  1487.          */
  1489.         case _DHCP_HOSTNAME_TAG:  /* Option Tag 12 */
  1490.             pDest = dhcpcOptCreate (option, pOptList->pTag12, pData, length);
  1491.             if (pDest == NULL)
  1492.                 {
  1493.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1494.                 return (ERROR);
  1495.                 }
  1496.             else
  1497.                 pOptList->pTag12 = pDest;
  1498.             break;
  1500.         case _DHCP_MERIT_DUMP_TAG:  /* Option Tag 14 */
  1501.             pDest = dhcpcOptCreate (option, pOptList->pTag14, pData, length);
  1502.             if (pDest == NULL)
  1503.                 {
  1504.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1505.                 return (ERROR);
  1506.                 }
  1507.             else
  1508.                 pOptList->pTag14 = pDest;
  1509.             break;
  1510.         case _DHCP_DNS_DOMAIN_TAG:  /* Option Tag 15 */
  1511.             pDest = dhcpcOptCreate (option, pOptList->pTag15, pData, length);
  1512.             if (pDest == NULL)
  1513.                 {
  1514.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1515.                 return (ERROR);
  1516.                 }
  1517.             else
  1518.                 pOptList->pTag15 = pDest;
  1519.             break;
  1520.         case _DHCP_ROOT_PATH_TAG:  /* Option Tag 17 */
  1521.             pDest = dhcpcOptCreate (option, pOptList->pTag17, pData, length);
  1522.             if (pDest == NULL)
  1523.                 {
  1524.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1525.                 return (ERROR);
  1526.                 }
  1527.             else
  1528.                 pOptList->pTag17 = pDest;
  1529.             break;
  1530.         case _DHCP_EXTENSIONS_PATH_TAG:  /* Option Tag 18 */
  1531.             pDest = dhcpcOptCreate (option, pOptList->pTag18, pData, length);
  1532.             if (pDest == NULL)
  1533.                 {
  1534.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1535.                 return (ERROR);
  1536.                 }
  1537.             else
  1538.                 pOptList->pTag18 = pDest;
  1539.             break;
  1540.         case _DHCP_NIS_DOMAIN_TAG:  /* Option Tag 40 */
  1541.             pDest = dhcpcOptCreate (option, pOptList->pTag40, pData, length);
  1542.             if (pDest == NULL)
  1543.                 {
  1544.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1545.                 return (ERROR);
  1546.                 }
  1547.             else
  1548.                 pOptList->pTag40 = pDest;
  1549.             break;
  1550.         case _DHCP_NB_SCOPE_TAG:  /* Option Tag 47 */
  1551.             pDest = dhcpcOptCreate (option, pOptList->pTag47, pData, length);
  1552.             if (pDest == NULL)
  1553.                 {
  1554.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1555.                 return (ERROR);
  1556.                 }
  1557.             else
  1558.                 pOptList->pTag47 = pDest;
  1559.             break;
  1560.         case _DHCP_ERRMSG_TAG:  /* Option Tag 56 */
  1561.             pDest = dhcpcOptCreate (option, pOptList->pTag56, pData, length);
  1562.             if (pDest == NULL)
  1563.                 {
  1564.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1565.                 return (ERROR);
  1566.                 }
  1567.             else
  1568.                 pOptList->pTag56 = pDest;
  1569.             break;
  1570.         case _DHCP_CLASS_ID_TAG:  /* Option Tag 60 */
  1571.             pDest = dhcpcOptCreate (option, pOptList->pTag60, pData, length);
  1572.             if (pDest == NULL)
  1573.                 {
  1574.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1575.                 return (ERROR);
  1576.                 }
  1577.             else
  1578.                 pOptList->pTag60 = pDest;
  1579.             break;
  1580.         case _DHCP_CLIENT_ID_TAG:  /* Option Tag 61 */
  1581.             /*
  1582.              * This option is also stored separately since it is included
  1583.              * independently in DECLINE and RELEASE messages.
  1584.              */
  1586.             if (pReqSpec->clid == NULL)
  1587.                 {
  1588.                 pReqSpec->clid = malloc (sizeof (struct client_id));
  1589.                 if (pReqSpec->clid == NULL)
  1590.                     {
  1591.                     errno = S_dhcpcLib_OPTION_NOT_STORED;
  1592.                     return (ERROR);
  1593.                     }
  1594.                 bzero ( (char *)pReqSpec->clid, sizeof (struct client_id));
  1595.                 }
  1597.             if (pReqSpec->clid->id != NULL)
  1598.                 free (pReqSpec->clid->id);
  1600.             pReqSpec->clid->id = malloc (length * sizeof (char));
  1601.             if (pReqSpec->clid->id == NULL)
  1602.                 {
  1603.                 free (pReqSpec->clid);
  1604.                 pReqSpec->clid = NULL;
  1605.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1606.                 return (ERROR);
  1607.                 }
  1609.             bcopy (pData, pReqSpec->clid->id, length);
  1610.             pReqSpec->clid->len = length;
  1612.             pDest = dhcpcOptCreate (option, pOptList->pTag61, pData, length);
  1613.             if (pDest == NULL)
  1614.                 {
  1615.                 free (pReqSpec->clid->id);
  1616.                 free (pReqSpec->clid);
  1617.                 pReqSpec->clid = NULL;
  1618.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1619.                 return (ERROR);
  1620.                 }
  1621.             else
  1622.                 pOptList->pTag61 = pDest;
  1623.             break;
  1624.         case _DHCP_NISP_DOMAIN_TAG:  /* Option Tag 64 */
  1625.             pDest = dhcpcOptCreate (option, pOptList->pTag64, pData, length);
  1626.             if (pDest == NULL)
  1627.                 {
  1628.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1629.                 return (ERROR);
  1630.                 }
  1631.             else
  1632.                 pOptList->pTag64 = pDest;
  1633.             break;
  1634.         case _DHCP_TFTP_SERVERNAME_TAG:  /* Option Tag 66 */
  1635.             pDest = dhcpcOptCreate (option, pOptList->pTag66, pData, length);
  1636.             if (pDest == NULL)
  1637.                 {
  1638.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1639.                 return (ERROR);
  1640.                 }
  1641.             else
  1642.                 pOptList->pTag66 = pDest;
  1643.             break;
  1644.         case _DHCP_BOOTFILE_TAG:  /* Option Tag 67 */
  1645.             pDest = dhcpcOptCreate (option, pOptList->pTag67, pData, length);
  1646.             if (pDest == NULL)
  1647.                 {
  1648.                 errno = S_dhcpcLib_OPTION_NOT_STORED;
  1649.                 return (ERROR);
  1650.                 }
  1651.             else
  1652.                 pOptList->pTag67 = pDest;
  1653.             break;
  1654.         }
  1656.     pReqSpec->pOptList->optlen += length + 2;
  1657.     SETBIT (pOptList->optmask, option);
  1659.     return (OK);
  1660.     }
  1662. /*******************************************************************************
  1663. *
  1664. * dhcpcOptionMerge - combine options into a single body
  1665. *
  1666. * The dhcpcOptionAdd() routine uses this routine to extend an existing option
  1667. * body, if any, with new data. This merge operation is required when the same
  1668. * option is inserted more than once for a given tag. If no option currently
  1669. * exists, this routine just creates the new option subfield. The <pOrig>
  1670. * parameter contains the current option subfield, or NULL if none exists yet.
  1671. * The <pData> parameter contains <length> bytes of additional option data.
  1672. *
  1673. * RETURNS: Pointer to new option subfield, or NULL if error occurs.
  1674. *
  1675. * NOMANUAL
  1676. */
  1678. UCHAR * dhcpcOptionMerge
  1679.     (
  1680.     UCHAR option,  /* RFC 2132 tag of desired option */
  1681.     UCHAR *  pOrig,  /* current option subfield, or NULL if none */
  1682.     UCHAR *  pData,  /* additional/first option body */
  1683.     int  length  /* amount of new data */
  1684.     )
  1685.     {
  1686.     int optlen;  /* Size of current subfield */
  1687.     int newlen;  /* Size of new subfield */
  1689.     UCHAR * pDest;
  1691.     if (pOrig != NULL)
  1692.         optlen = * (pOrig + 1);
  1693.     else
  1694.         optlen = 0;
  1696.     optlen += 2;  /* Adjust for tag and length values. */
  1698.     newlen = optlen + length;
  1700.     if (newlen > 255)  /* Merged option exceeds maximum length. */
  1701.         return (NULL);
  1703.     pDest = malloc (newlen);
  1704.     if (pDest != NULL)
  1705.         {
  1706.         if (pOrig != NULL)
  1707.             {
  1708.             bcopy (pOrig, pDest, optlen);
  1709.             free (pOrig);
  1710.             }
  1711.         else
  1712.             *pDest = option;
  1714.         * (pDest + 1) = newlen;    /* Update length field to new value. */
  1716.         bcopy (pData, pDest + optlen, length);
  1717.         }
  1719.     return (pDest);
  1720.     }
  1722. /*******************************************************************************
  1723. *
  1724. * dhcpcOptCreate - generate a new subfield for variable-length options
  1725. *
  1726. * The dhcpcOptionAdd() routine uses this routine to create or replace an
  1727. * option subfield. The <pOrig> parameter contains the current option subfield,
  1728. * or NULL if none exists yet. The <pData> parameter contains <length> bytes of
  1729. * option data for the new (or initial) subfield.
  1730. *
  1731. * RETURNS: Pointer to new option subfield, or NULL if error occurs.
  1732. *
  1733. * NOMANUAL
  1734. */
  1736. UCHAR * dhcpcOptCreate
  1737.     (
  1738.     UCHAR option,  /* RFC 2132 tag of desired option */
  1739.     UCHAR *  pOrig,  /* current option subfield, or NULL if none */
  1740.     UCHAR *  pData,  /* additional/first option body */
  1741.     int  length  /* amount of new data */
  1742.     )
  1743.     {
  1744.     UCHAR * pDest;
  1746.     pDest = malloc (length + 2);    /* Adjusts for tag and length */
  1747.     if (pDest != NULL)
  1748.         {
  1749.         *pDest = option;
  1750.         * (pDest + 1) = length;
  1751.         bcopy (pData, pDest + 2, length);
  1753.         if (pOrig != NULL)
  1754.             free (pOrig);
  1755.         }
  1757.     return (pDest);
  1758.     }
  1760. /*******************************************************************************
  1761. *
  1762. * dhcpcOptFieldCreate - fill in the options field for outgoing messages
  1763. *
  1764. * The boot-time and run-time DHCP clients use this routine to fill the
  1765. * options field for all outgoing messages from the available entries in
  1766. * the <pOptList> structure. Any memory used for variable-length subfields
  1767. * within that structure is released. The <pOptions> parameter indicates the
  1768. * destination for the options to be included in all outgoing messages. This
  1769. * routine ignores the contents for the "requested IP address" option, if
  1770. * present, since that option cannot always be included in the initial message.
  1771. *
  1772. * RETURNS: N/A
  1773. *
  1774. * NOMANUAL
  1775. */
  1777. void dhcpcOptFieldCreate
  1778.     (
  1779.     struct dhcpcOpts *  pOptList,  /* Available options for message */
  1780.     UCHAR *   pOptions  /* Resulting message field */
  1781.     )
  1782.     {
  1783.     int  loop;
  1784.     int  optlen = 0;
  1785.     UCHAR *  pData = NULL;
  1786.     UCHAR *  pDest;
  1787.     BOOL  copyFlag;
  1789.     pDest = pOptions;
  1791.     for (loop = 0; loop < MAXTAGNUM; loop++)
  1792.         {
  1793.         if (ISSET (pOptList->optmask, loop))
  1794.             {
  1795.             copyFlag = FALSE;
  1797.             /* 
  1798.              * For fixed size options, copy option body after inserting
  1799.              * option tag and length.
  1800.              */
  1802.             switch (loop)
  1803.                 {
  1804.                 /* 1 byte values */
  1806.                 case _DHCP_IP_FORWARD_TAG:  /* Option Tag 19 */
  1807.                     optlen = 1;
  1808.                     pData = &pOptList->tag19;
  1809.                     copyFlag = TRUE; 
  1810.                     break;    
  1811.                 case _DHCP_NONLOCAL_SRCROUTE_TAG:  /* Option Tag 20 */
  1812.                     optlen = 1;
  1813.                     pData = &pOptList->tag20;
  1814.                     copyFlag = TRUE; 
  1815.                     break;
  1816.                 case _DHCP_DEFAULT_IP_TTL_TAG:  /* Option Tag 23 */
  1817.                     optlen = 1;
  1818.                     pData = &pOptList->tag23;
  1819.                     copyFlag = TRUE; 
  1820.                     break;
  1821.                 case _DHCP_ALL_SUBNET_LOCAL_TAG:  /* Option Tag 27 */
  1822.                     optlen = 1;
  1823.                     pData = &pOptList->tag27;
  1824.                     copyFlag = TRUE; 
  1825.                     break;
  1826.                 case _DHCP_MASK_DISCOVER_TAG:  /* Option Tag 29 */
  1827.                     optlen = 1;
  1828.                     pData = &pOptList->tag29;
  1829.                     copyFlag = TRUE; 
  1830.                     break;
  1831.                 case _DHCP_MASK_SUPPLIER_TAG:  /* Option Tag 30 */
  1832.                     optlen = 1;
  1833.                     pData = &pOptList->tag30;
  1834.                     copyFlag = TRUE; 
  1835.                     break;
  1836.                 case _DHCP_ROUTER_DISCOVER_TAG:  /* Option Tag 31 */
  1837.                     optlen = 1;
  1838.                     pData = &pOptList->tag31;
  1839.                     copyFlag = TRUE; 
  1840.                     break;
  1841.                 case _DHCP_TRAILER_TAG:  /* Option Tag 34 */
  1842.                     optlen = 1;
  1843.                     pData = &pOptList->tag34;
  1844.                     copyFlag = TRUE; 
  1845.                     break;
  1846.                 case _DHCP_ETHER_ENCAP_TAG:  /* Option Tag 36 */
  1847.                     optlen = 1;
  1848.                     pData = &pOptList->tag36;
  1849.                     copyFlag = TRUE; 
  1850.                     break;
  1851.                 case _DHCP_DEFAULT_TCP_TTL_TAG:  /* Option Tag 37 */
  1852.                     optlen = 1;
  1853.                     pData = &pOptList->tag37;
  1854.                     copyFlag = TRUE; 
  1855.                     break;
  1856.                 case _DHCP_KEEPALIVE_GARBAGE_TAG:  /* Option Tag 39 */
  1857.                     optlen = 1;
  1858.                     pData = &pOptList->tag39;
  1859.                     copyFlag = TRUE; 
  1860.                     break;
  1861.                 case _DHCP_NB_NODETYPE_TAG:  /* Option Tag 46 */
  1862.                     optlen = 1;
  1863.                     pData = &pOptList->tag46;
  1864.                     copyFlag = TRUE; 
  1865.                     break;
  1867.                 /* 2 byte values */
  1869.                 case _DHCP_BOOTSIZE_TAG:  /* Option Tag 13 */
  1870.                     optlen = 2;
  1871.                     pData = (UCHAR *)&pOptList->tag13;
  1872.                     copyFlag = TRUE; 
  1873.                     break;
  1874.                 case _DHCP_MAX_DGRAM_SIZE_TAG:  /* Option Tag 22 */
  1875.                     optlen = 2;
  1876.                     pData = (UCHAR *)&pOptList->tag22;
  1877.                     copyFlag = TRUE; 
  1878.                     break;
  1879.                 case _DHCP_IF_MTU_TAG:  /* Option Tag 26 */
  1880.                     optlen = 2;
  1881.                     pData = (UCHAR *)&pOptList->tag26;
  1882.                     copyFlag = TRUE; 
  1883.                     break;
  1885.                 /* 4 byte values */
  1887.                 case _DHCP_SUBNET_MASK_TAG:  /* Option Tag 1 */
  1888.                     optlen = 4;
  1889.                     pData = (UCHAR *)&pOptList->tag1;
  1890.                     copyFlag = TRUE; 
  1891.                     break;
  1892.                 case _DHCP_TIME_OFFSET_TAG:  /* Option Tag 2 */
  1893.                     optlen = 4;
  1894.                     pData = (UCHAR *)&pOptList->tag2;
  1895.                     copyFlag = TRUE; 
  1896.                     break;
  1897.                 case _DHCP_SWAP_SERVER_TAG:  /* Option Tag 16 */
  1898.                     optlen = 4;
  1899.                     pData = (UCHAR *)&pOptList->tag16;
  1900.                     copyFlag = TRUE; 
  1901.                     break;
  1902.                 case _DHCP_MTU_AGING_TIMEOUT_TAG:  /* Option Tag 24 */
  1903.                     optlen = 4;
  1904.                     pData = (UCHAR *)&pOptList->tag24;
  1905.                     copyFlag = TRUE; 
  1906.                     break;
  1907.                 case _DHCP_BRDCAST_ADDR_TAG:  /* Option Tag 28 */
  1908.                     optlen = 4;
  1909.                     pData = (UCHAR *)&pOptList->tag28;
  1910.                     copyFlag = TRUE; 
  1911.                     break;
  1912.                 case _DHCP_ROUTER_SOLICIT_TAG:  /* Option Tag 32 */
  1913.                     optlen = 4;
  1914.                     pData = (UCHAR *)&pOptList->tag32;
  1915.                     copyFlag = TRUE; 
  1916.                     break;
  1917.                 case _DHCP_ARP_CACHE_TIMEOUT_TAG:  /* Option Tag 35 */
  1918.                     optlen = 4;
  1919.                     pData = (UCHAR *)&pOptList->tag35;
  1920.                     copyFlag = TRUE; 
  1921.                     break;
  1922.                 case _DHCP_KEEPALIVE_INTERVAL_TAG:  /* Option Tag 38 */
  1923.                     optlen = 4;
  1924.                     pData = (UCHAR *)&pOptList->tag38;
  1925.                     copyFlag = TRUE; 
  1926.                     break;
  1927.                 case _DHCP_LEASE_TIME_TAG:  /* Option Tag 51 */
  1928.                     optlen = 4;
  1929.                     pData = (UCHAR *)&pOptList->tag51;
  1930.                     copyFlag = TRUE; 
  1931.                     break;
  1932.                 case _DHCP_T1_TAG:  /* Option Tag 58 */
  1933.                     optlen = 4;
  1934.                     pData = (UCHAR *)&pOptList->tag58;
  1935.                     copyFlag = TRUE; 
  1936.                     break;
  1937.                 case _DHCP_T2_TAG:  /* Option Tag 59 */
  1938.                     optlen = 4;
  1939.                     pData = (UCHAR *)&pOptList->tag59;
  1940.                     copyFlag = TRUE; 
  1941.                     break;
  1942.                 }
  1944.             if (copyFlag)
  1945.                 {
  1946.                 *pDest++ = (UCHAR)loop;
  1947.                 *pDest++ = (UCHAR)optlen;
  1948.                 bcopy (pData, pDest, optlen);
  1949.                 pDest += optlen;
  1950.                 continue;
  1951.                 }
  1953.             /* 
  1954.              * For variable length options, copy the entry (which already
  1955.              * includes the option tag and length) then release the memory.
  1956.              */
  1958.             switch (loop)
  1959.                 {
  1960.                 case _DHCP_MTU_PLATEAU_TABLE_TAG:  /* Option Tag 25 */
  1961.                     pData = pOptList->pTag25;
  1962.                     break;
  1963.                 case _DHCP_ROUTER_TAG:  /* Option Tag 3 */
  1964.                     pData = pOptList->pTag3;
  1965.                     break;
  1966.                 case _DHCP_TIME_SERVER_TAG:  /* Option Tag 4 */
  1967.                     pData = pOptList->pTag4;
  1968.                     break;
  1969.                 case _DHCP_NAME_SERVER_TAG:  /* Option Tag 5 */
  1970.                     pData = pOptList->pTag5;
  1971.                     break;
  1972.                 case _DHCP_DNS_SERVER_TAG:  /* Option Tag 6 */
  1973.                     pData = pOptList->pTag6;
  1974.                     break;
  1975.                 case _DHCP_LOG_SERVER_TAG:  /* Option Tag 7 */
  1976.                     pData = pOptList->pTag7;
  1977.                     break;
  1978.                 case _DHCP_COOKIE_SERVER_TAG:  /* Option Tag 8 */
  1979.                     pData = pOptList->pTag8;
  1980.                     break;
  1981.                 case _DHCP_LPR_SERVER_TAG:  /* Option Tag 9 */
  1982.                     pData = pOptList->pTag9;
  1983.                     break;
  1984.                 case _DHCP_IMPRESS_SERVER_TAG:  /* Option Tag 10 */
  1985.                     pData = pOptList->pTag10;
  1986.                     break;
  1987.                 case _DHCP_RLS_SERVER_TAG:  /* Option Tag 11 */
  1988.                     pData = pOptList->pTag11;
  1989.                     break;
  1990.                 case _DHCP_NIS_SERVER_TAG:  /* Option Tag 41 */
  1991.                     pData = pOptList->pTag41;
  1992.                     break;
  1993.                 case _DHCP_NTP_SERVER_TAG:  /* Option Tag 42 */
  1994.                     pData = pOptList->pTag42;
  1995.                     break;
  1996.                 case _DHCP_NBN_SERVER_TAG:  /* Option Tag 44 */
  1997.                     pData = pOptList->pTag44;
  1998.                     break;
  1999.                 case _DHCP_NBDD_SERVER_TAG:  /* Option Tag 45 */
  2000.                     pData = pOptList->pTag45;
  2001.                     break;
  2002.                 case _DHCP_XFONT_SERVER_TAG:  /* Option Tag 48 */
  2003.                     pData = pOptList->pTag48;
  2004.                     break;
  2005.                 case _DHCP_XDISPLAY_MANAGER_TAG:  /* Option Tag 49 */
  2006.                     pData = pOptList->pTag49;
  2007.                     break;
  2008.                 case _DHCP_NISP_SERVER_TAG:  /* Option Tag 65 */
  2009.                     pData = pOptList->pTag65;
  2010.                     break;
  2011.                 case _DHCP_MOBILEIP_HA_TAG:  /* Option Tag 68 */
  2012.                     pData = pOptList->pTag68;
  2013.                     break;
  2014.                 case _DHCP_SMTP_SERVER_TAG:  /* Option Tag 69 */
  2015.                     pData = pOptList->pTag69;
  2016.                     break;
  2017.                 case _DHCP_POP3_SERVER_TAG:  /* Option Tag 70 */
  2018.                     pData = pOptList->pTag70;
  2019.                     break;
  2020.                 case _DHCP_NNTP_SERVER_TAG:  /* Option Tag 71 */
  2021.                     pData = pOptList->pTag71;
  2022.                     break;
  2023.                 case _DHCP_DFLT_WWW_SERVER_TAG:  /* Option Tag 72 */
  2024.                     pData = pOptList->pTag72;
  2025.                     break;
  2026.                 case _DHCP_DFLT_FINGER_SERVER_TAG:  /* Option Tag 73 */
  2027.                     pData = pOptList->pTag73;
  2028.                     break;
  2029.                 case _DHCP_DFLT_IRC_SERVER_TAG:   /* Option Tag 74 */
  2030.                     pData = pOptList->pTag74;
  2031.                     break;
  2032.                 case _DHCP_STREETTALK_SERVER_TAG:   /* Option Tag 75 */
  2033.                     pData = pOptList->pTag75;
  2034.                     break;
  2035.                 case _DHCP_STDA_SERVER_TAG:  /* Option Tag 76 */
  2036.                     pData = pOptList->pTag76;
  2037.                     break;
  2038.                 case _DHCP_POLICY_FILTER_TAG:  /* Option Tag 21 */
  2039.                     pData = pOptList->pTag21;
  2040.                     break;
  2041.                 case _DHCP_STATIC_ROUTE_TAG:  /* Option Tag 33 */
  2042.                     pData = pOptList->pTag33;
  2043.                     break;
  2044.                 case _DHCP_VENDOR_SPEC_TAG:  /* Option Tag 43 */
  2045.                     pData = pOptList->pTag43;
  2046.                     break;
  2047.                 case _DHCP_REQ_LIST_TAG:  /* Option Tag 55 */
  2048.                     pData = pOptList->pTag55;
  2049.                     break;
  2050.                 case _DHCP_HOSTNAME_TAG:  /* Option Tag 12 */
  2051.                     pData = pOptList->pTag12;
  2052.                     break;
  2053.                 case _DHCP_MERIT_DUMP_TAG:  /* Option Tag 14 */
  2054.                     pData = pOptList->pTag14;
  2055.                     break;
  2056.                 case _DHCP_DNS_DOMAIN_TAG:  /* Option Tag 15 */
  2057.                     pData = pOptList->pTag15;
  2058.                     break;
  2059.                 case _DHCP_ROOT_PATH_TAG:  /* Option Tag 17 */
  2060.                     pData = pOptList->pTag17;
  2061.                     break;
  2062.                 case _DHCP_EXTENSIONS_PATH_TAG:  /* Option Tag 18 */
  2063.                     pData = pOptList->pTag18;
  2064.                     break;
  2065.                 case _DHCP_NIS_DOMAIN_TAG:  /* Option Tag 40 */
  2066.                     pData = pOptList->pTag40;
  2067.                     break;
  2068.                 case _DHCP_NB_SCOPE_TAG:  /* Option Tag 47 */
  2069.                     pData = pOptList->pTag47;
  2070.                     break;
  2071.                 case _DHCP_ERRMSG_TAG:  /* Option Tag 56 */
  2072.                     pData = pOptList->pTag56;
  2073.                     break;
  2074.                 case _DHCP_CLASS_ID_TAG:  /* Option Tag 60 */
  2075.                     pData = pOptList->pTag60;
  2076.                     break;
  2077.                 case _DHCP_CLIENT_ID_TAG:  /* Option Tag 61 */
  2078.                     pData = pOptList->pTag61;
  2079.                     break;
  2080.                 case _DHCP_NISP_DOMAIN_TAG:  /* Option Tag 64 */
  2081.                     pData = pOptList->pTag64;
  2082.                     break;
  2083.                 case _DHCP_TFTP_SERVERNAME_TAG:  /* Option Tag 66 */
  2084.                     pData = pOptList->pTag66;
  2085.                     break;
  2086.                 case _DHCP_BOOTFILE_TAG:  /* Option Tag 67 */
  2087.                     pData = pOptList->pTag67;
  2088.                     break;
  2089.                 }
  2091.             optlen = *(pData + 1);
  2092.             optlen += 2;  /* Adjust for tag and length value. */
  2093.             bcopy (pData, pDest, optlen);
  2094.             pDest += optlen;
  2096.             free (pData);
  2097.             }    /* END: if (ISSET (<option value>) */
  2098.         }    /* END: loop */
  2099.     return;
  2100.     }
  2102. /******************************************************************************
  2103. *
  2104. * dhcpcDefaultsSet - assign host requirements defaults for client
  2105. *
  2106. * This routine fills the client's parameters structure with the default
  2107. * values specified in the Host Requirements Documents (RFC's 1122 and 1123),
  2108. * the Path MTU Discovery description (RFC 1191), or the Router Discovery
  2109. * specification (RFC 1256). This data is assigned before processing a message 
  2110. * received from a DHCP server, so that it can override the defaults.
  2111. *
  2112. * RETURNS: N/A
  2113. *
  2114. * ERRNO: N/A
  2115. *
  2116. * NOMANUAL
  2117. */
  2119. void dhcpcDefaultsSet
  2120.     (
  2121.     struct dhcp_param *  pNewParam
  2122.     )
  2123.     {
  2124.     /* Default IP layer parameters, per host. */
  2126.     pNewParam->ip_forward = FALSE;
  2127.     pNewParam->nonlocal_srcroute = FALSE;
  2128.     pNewParam->max_dgram_size = _HRD_MAX_DGRAM;
  2129.     pNewParam->default_ip_ttl = _HRD_IP_TTL;
  2131.     /* Default IP layer parameters, per interface. */
  2133.     pNewParam->intf_mtu = _HRD_MTU;
  2134.     pNewParam->all_subnet_local = FALSE;
  2135.     pNewParam->mask_discover = FALSE;
  2136.     pNewParam->mask_supplier = FALSE;
  2137.     pNewParam->router_discover = TRUE;
  2138.     pNewParam->router_solicit.s_addr = _HRD_ROUTER;
  2140.     /* Default link layer parameters, per interface. */
  2142.     pNewParam->trailer = FALSE;
  2143.     pNewParam->arp_cache_timeout = _HRD_ARP_TIME;
  2144.     pNewParam->ether_encap = FALSE;
  2146.     /* Default link layer parameters, per host. */
  2148.     pNewParam->default_tcp_ttl = _HRD_TCP_TTL;
  2149.     pNewParam->keepalive_inter = _HRD_TCP_TIME;
  2150.     pNewParam->keepalive_garba = FALSE;
  2151.     }
  2153. /******************************************************************************
  2154. *
  2155. * dhcpcEventAdd - send event notification to monitor task
  2156. *
  2157. * This routine adds event descriptors to the event queue for later handling 
  2158. * by the DHCP client monitor task. 
  2159. *
  2160. * If the <source> parameter is set to DHCP_USER_EVENT, the routine was called 
  2161. * by one of the following API routines: dhcpcInformGet(), dhcpcBind(),
  2162. * dhcpcRelease(), dhcpcVerify(), or dhcpcShutdown(). The <type> parameter
  2163. * indicates the corresponding action: DHCP_USER_INFORM to get additional
  2164. * configuration parameters without establishing a lease, DHCP_USER_BIND to
  2165. * initiate the lease negotiation process, DHCP_USER_VERIFY to verify an
  2166. * active lease, DHCP_USER_RELEASE to relinquish an active lease or
  2167. * remove additional parameters, and DHCP_USER_SHUTDOWN to release all sets
  2168. * of configuration parameters and disable the DHCP client library. 
  2169. *
  2170. * If the <source> parameter is set to DHCP_AUTO_EVENT, the routine was called
  2171. * in response to a timeout in the DHCP client state machine and the
  2172. * <type> parameter is set to DHCP_TIMEOUT.
  2173. *
  2174. * The <pLeaseId> parameter identifies the configuration parameters (usually
  2175. * associated with a lease) for timeout events and the first four user events.
  2176. *
  2177. * The <intFlag> parameter indicates if this routine is executing at interrupt 
  2178. * level. If it is FALSE, then interrupts must be locked out to prevent
  2179. * write conflicts to the event ring buffer between user requests and watchdog 
  2180. * timers.
  2181. *
  2182. * RETURNS: OK if event added successfully, or ERROR otherwise.
  2183. *
  2184. * ERRNO: N/A
  2185. *
  2186. * NOMANUAL
  2187. */ 
  2189. STATUS dhcpcEventAdd
  2190.     (
  2191.     int  source,  /* automatic event or user request */
  2192.     int  type,  /* event identifier */
  2193.     void *  pLeaseId, /* internal lease identifier */
  2194.     BOOL  intFlag  /* executing at interrupt level? */
  2195.     )
  2196.     {
  2197.     EVENT_DATA  newEvent;
  2198.     int  status;
  2199.     int  key = 0;
  2201.     newEvent.source = source;
  2202.     newEvent.type = type;
  2203.     newEvent.leaseId = pLeaseId;
  2205.     /*
  2206.      * Add the event to the monitor task's event list. 
  2207.      * Disable interrupts if necessary. 
  2208.      */
  2210.     if (!intFlag)
  2211.         key = intLock ();
  2212.     status = rngBufPut (dhcpcEventRing, (char *)&newEvent, sizeof (newEvent));
  2213.     if (!intFlag)
  2214.         intUnlock (key);
  2216.     if (status != sizeof (newEvent))
  2217.         return (ERROR);
  2219.     /* Signal the monitor task of the event arrival. */
  2221.     status = semGive (dhcpcEventSem);
  2222.     if (status == ERROR)
  2223.         return (ERROR);
  2225.     return (OK);
  2226.     }
  2228. /******************************************************************************
  2229. *
  2230. * dhcpcParamsCopy - copy current network parameters.
  2231. *
  2232. * This routine copies the network parameters to the caller-supplied structure.
  2233. * A run-time session calls this routine internally with the dhcpcParamsGet()
  2234. * routine and the <pLeaseData> parameter identifies the target lease. The DHCP
  2235. * boot-time session also uses this routine within the dhcpcBootParamsGet()
  2236. * routine. In that case, the parameters accessed through the lease structure
  2237. * for compatibility with the interface are actually available directly.
  2238. *
  2239. * RETURNS: N/A
  2240. *
  2241. * ERRNO: N/A
  2242. *
  2243. * NOMANUAL
  2244. *
  2245. * INTERNAL
  2246. * The data structure accessed by this routine was defined by the original
  2247. * public domain code used as a basis for the DHCP implementation. The 
  2248. * structure tag and field names are not required to follow the coding 
  2249. * standards (and they don't).
  2250. */
  2252. void dhcpcParamsCopy
  2253.     (
  2254.     LEASE_DATA *  pLeaseData,
  2255.     struct dhcp_param * pParamList 
  2256.     )
  2257.     {
  2258.     int loop;
  2259.     int limit = 0;
  2260.     struct dhcp_param * pDhcpcParam;
  2262.     /*
  2263.      * The DHCP client parameters received from the server are stored in a 
  2264.      * large structure which either contains the actual parameter value 
  2265.      * or a pointer to the data. Because the parameters received are 
  2266.      * determined by the server configuration and many parameters are
  2267.      * optional, any of the fields could use the default value determined
  2268.      * earlier. In most cases, the default value is an empty field (or
  2269.      * zero in the case of numeric values). However, some parameters contain 
  2270.      * default settings specified by the host requirements documents which are 
  2271.      * used if the server does not provide a value. The following code copies 
  2272.      * any available parameters into the provided target structure. If 
  2273.      * necessary, it checks for empty fields. The code is divided into logical 
  2274.      * blocks according to the various data types used by the DHCP parameters.
  2275.      */
  2277.     pDhcpcParam = pLeaseData->dhcpcParam;
  2279.     /* Process all string parameters. */
  2281.     bcopy (pDhcpcParam->got_option, pParamList->got_option, OPTMASKSIZE);
  2283.     if (pParamList->sname != NULL && pDhcpcParam->sname != NULL)
  2284.         strcpy (pParamList->sname, pDhcpcParam->sname);
  2286.     if (pParamList->file  != NULL && pDhcpcParam->file != NULL)
  2287.         strcpy (pParamList->file, pDhcpcParam->file);
  2289.     if (pParamList->hostname != NULL && pDhcpcParam->hostname != NULL)
  2290.         strcpy (pParamList->hostname, pDhcpcParam->hostname);
  2292.     if (pParamList->merit_dump != NULL && pDhcpcParam->merit_dump != NULL)
  2293.         strcpy (pParamList->merit_dump, pDhcpcParam->merit_dump);
  2295.     if (pParamList->dns_domain != NULL && pDhcpcParam->dns_domain != NULL)
  2296.         strcpy (pParamList->dns_domain, pDhcpcParam->dns_domain);
  2298.     if (pParamList->root_path != NULL && pDhcpcParam->root_path != NULL)
  2299.         strcpy (pParamList->root_path, pDhcpcParam->root_path);
  2301.     if (pParamList->extensions_path != NULL && 
  2302.         pDhcpcParam->extensions_path != NULL)
  2303.         strcpy (pParamList->extensions_path, pDhcpcParam->extensions_path);
  2305.     if (pParamList->nis_domain != NULL && pDhcpcParam->nis_domain != NULL)
  2306.         strcpy (pParamList->nis_domain, pDhcpcParam->nis_domain);
  2308.     if (pParamList->nb_scope != NULL && pDhcpcParam->nb_scope != NULL)
  2309.         strcpy (pParamList->nb_scope, pDhcpcParam->nb_scope);
  2311.     if (pParamList->errmsg != NULL && pDhcpcParam->errmsg != NULL)
  2312.         strcpy (pParamList->errmsg, pDhcpcParam->errmsg);
  2314.     if (pParamList->nisp_domain != NULL && pDhcpcParam->nisp_domain != NULL)
  2315.         strcpy (pParamList->nisp_domain, pDhcpcParam->nisp_domain);
  2317.     /* Process all boolean parameters. */
  2319.     pParamList->ip_forward = pDhcpcParam->ip_forward;
  2320.     pParamList->nonlocal_srcroute = pDhcpcParam->nonlocal_srcroute;
  2321.     pParamList->all_subnet_local = pDhcpcParam->all_subnet_local;
  2322.     pParamList->mask_discover = pDhcpcParam->mask_discover;
  2323.     pParamList->mask_supplier = pDhcpcParam->mask_supplier;
  2324.     pParamList->router_discover = pDhcpcParam->router_discover;
  2325.     pParamList->trailer = pDhcpcParam->trailer;
  2326.     pParamList->ether_encap = pDhcpcParam->ether_encap;
  2327.     pParamList->keepalive_garba = pDhcpcParam->keepalive_garba;
  2329.     /* Process all single numeric parameters. */
  2331.     pParamList->time_offset = pDhcpcParam->time_offset;
  2332.     pParamList->bootsize = pDhcpcParam->bootsize;
  2333.     pParamList->max_dgram_size = pDhcpcParam->max_dgram_size;
  2334.     pParamList->default_ip_ttl = pDhcpcParam->default_ip_ttl;
  2335.     pParamList->mtu_aging_timeout = pDhcpcParam->mtu_aging_timeout;
  2336.     pParamList->intf_mtu = pDhcpcParam->intf_mtu;
  2337.     pParamList->arp_cache_timeout = pDhcpcParam->arp_cache_timeout;
  2338.     pParamList->default_tcp_ttl = pDhcpcParam->default_tcp_ttl;
  2339.     pParamList->keepalive_inter = pDhcpcParam->keepalive_inter;
  2340.     pParamList->nb_nodetype = pDhcpcParam->nb_nodetype;
  2341.     pParamList->lease_origin = pDhcpcParam->lease_origin;
  2342.     pParamList->lease_duration = pDhcpcParam->lease_duration;
  2343.     pParamList->dhcp_t1 = pDhcpcParam->dhcp_t1;
  2344.     pParamList->dhcp_t2 = pDhcpcParam->dhcp_t2;
  2346.     /* Process multiple numeric parameters. */
  2348.     if (pParamList->mtu_plateau_table != NULL &&
  2349.         pDhcpcParam->mtu_plateau_table != NULL)
  2350.         {
  2351.         limit = 0;
  2352.         if (pParamList->mtu_plateau_table->shortnum != NULL)
  2353.             {
  2354.             limit = (pParamList->mtu_plateau_table->num <
  2355.                      pDhcpcParam->mtu_plateau_table->num) ?
  2356.                      pParamList->mtu_plateau_table->num :
  2357.                      pDhcpcParam->mtu_plateau_table->num;
  2358.             for (loop = 0; loop < limit; loop++)
  2359.                 {
  2360.                 pParamList->mtu_plateau_table->shortnum [loop] =
  2361.                 pDhcpcParam->mtu_plateau_table->shortnum [loop];
  2362.                 }
  2363.             }
  2364.         pParamList->mtu_plateau_table->num = limit;
  2365.         }
  2367.     /* Process single IP addresses. */
  2369.     pParamList->server_id = pDhcpcParam->server_id;
  2370.     pParamList->ciaddr = pDhcpcParam->ciaddr;
  2371.     pParamList->yiaddr = pDhcpcParam->yiaddr;
  2372.     pParamList->siaddr = pDhcpcParam->siaddr;
  2373.     pParamList->giaddr = pDhcpcParam->giaddr;
  2375.     if (pParamList->subnet_mask != NULL && pDhcpcParam->subnet_mask != NULL)
  2376.         bcopy ( (char *)pDhcpcParam->subnet_mask,
  2377.                (char *)pParamList->subnet_mask, sizeof (struct in_addr));
  2379.     if (pParamList->swap_server != NULL && pDhcpcParam->swap_server != NULL)
  2380.         bcopy ( (char *)pDhcpcParam->swap_server,
  2381.                (char *)pParamList->swap_server, sizeof (struct in_addr));
  2383.     if (pParamList->brdcast_addr != NULL &&
  2384.         pDhcpcParam->brdcast_addr != NULL)
  2385.         bcopy ( (char *)pDhcpcParam->brdcast_addr,
  2386.                (char *)pParamList->brdcast_addr, sizeof (struct in_addr));
  2388.     pParamList->router_solicit = pDhcpcParam->router_solicit;
  2390.     /* Process multiple IP addresses. */
  2392.     if (pParamList->router != NULL && pDhcpcParam->router != NULL)
  2393.         {
  2394.         limit = 0;
  2395.         if (pParamList->router->addr != NULL)
  2396.             {
  2397.             limit = (pParamList->router->num < pDhcpcParam->router->num) ?
  2398.                      pParamList->router->num : pDhcpcParam->router->num;
  2399.             for (loop = 0; loop < limit; loop++)
  2400.                 {
  2401.                 bcopy ( (char *)&pDhcpcParam->router->addr [loop],
  2402.                        (char *)&pParamList->router->addr [loop],
  2403.                        sizeof (struct in_addr));
  2404.                 }
  2405.             }
  2406.         pParamList->router->num = limit;
  2407.         }
  2409.     if (pParamList->time_server != NULL && pDhcpcParam->time_server != NULL)
  2410.         {
  2411.         limit = 0;
  2412.         if (pParamList->time_server->addr != NULL)
  2413.             {
  2414.             limit = (pParamList->time_server->num <
  2415.                      pDhcpcParam->time_server->num) ?
  2416.                      pParamList->time_server->num :
  2417.                      pDhcpcParam->time_server->num;
  2418.             for (loop = 0; loop < limit; loop++)
  2419.                 {
  2420.                 bcopy ( (char *)&pDhcpcParam->time_server->addr [loop],
  2421.                        (char *)&pParamList->time_server->addr [loop],
  2422.                        sizeof (struct in_addr));
  2423.                 }
  2424.             }
  2425.         pParamList->time_server->num = limit;
  2426.         }
  2428.     if (pParamList->name_server != NULL && pDhcpcParam->name_server != NULL)
  2429.         {
  2430.         limit = 0;
  2431.         if (pParamList->name_server->addr != NULL)
  2432.             {
  2433.             limit = (pParamList->name_server->num <
  2434.                      pDhcpcParam->name_server->num) ?
  2435.                      pParamList->name_server->num :
  2436.                      pDhcpcParam->name_server->num;
  2437.             for (loop = 0; loop < limit; loop++)
  2438.                 {
  2439.                 bcopy ( (char *)&pDhcpcParam->name_server->addr [loop],
  2440.                        (char *)&pParamList->name_server->addr [loop],
  2441.                        sizeof (struct in_addr));
  2442.                 }
  2443.             }
  2444.         pParamList->name_server->num = limit;
  2445.         }
  2447.     if (pParamList->dns_server != NULL && pDhcpcParam->dns_server != NULL)
  2448.         {
  2449.         limit = 0;
  2450.         if (pParamList->dns_server->addr != NULL)
  2451.             {
  2452.             limit = (pParamList->dns_server->num <
  2453.                      pDhcpcParam->dns_server->num) ?
  2454.                      pParamList->dns_server->num :
  2455.                      pDhcpcParam->dns_server->num;
  2456.             for (loop = 0; loop < limit; loop++)
  2457.                 {
  2458.                 bcopy ( (char *)&pDhcpcParam->dns_server->addr [loop],
  2459.                        (char *)&pParamList->dns_server->addr [loop],
  2460.                        sizeof (struct in_addr));
  2461.                 }
  2462.             }
  2463.         pParamList->dns_server->num = limit;
  2464.         }
  2466.     if (pParamList->log_server != NULL && pDhcpcParam->log_server != NULL)
  2467.         {
  2468.         limit = 0;
  2469.         if (pParamList->log_server->addr != NULL)
  2470.             {
  2471.             limit = (pParamList->log_server->num <
  2472.                      pDhcpcParam->log_server->num) ?
  2473.                      pParamList->log_server->num :
  2474.                      pDhcpcParam->log_server->num;
  2475.             for (loop = 0; loop < limit; loop++)
  2476.                 {
  2477.                 bcopy ( (char *)&pDhcpcParam->log_server->addr [loop],
  2478.                        (char *)&pParamList->log_server->addr [loop],
  2479.                        sizeof (struct in_addr));
  2480.                 }
  2481.             }
  2482.         pParamList->log_server->num = limit;
  2483.         }
  2485.     if (pParamList->cookie_server != NULL && 
  2486.         pDhcpcParam->cookie_server != NULL)
  2487.         {
  2488.         limit = 0;
  2489.         if (pParamList->cookie_server->addr != NULL)
  2490.             {
  2491.             limit = (pParamList->log_server->num <
  2492.                      pDhcpcParam->log_server->num) ?
  2493.                      pParamList->log_server->num :
  2494.                      pDhcpcParam->log_server->num;
  2495.             for (loop = 0; loop < limit; loop++)
  2496.                 {
  2497.                 bcopy ( (char *)&pDhcpcParam->cookie_server->addr [loop],
  2498.                        (char *)&pParamList->cookie_server->addr [loop],
  2499.                        sizeof (struct in_addr));
  2500.                 }
  2501.             }
  2502.         pParamList->cookie_server->num = limit;
  2503.         }
  2505.     if (pParamList->lpr_server != NULL && pDhcpcParam->lpr_server != NULL)
  2506.         {
  2507.         limit = 0;
  2508.         if (pParamList->lpr_server->addr != NULL)
  2509.             {
  2510.             limit = (pParamList->lpr_server->num <
  2511.                      pDhcpcParam->lpr_server->num) ?
  2512.                      pParamList->lpr_server->num :
  2513.                      pDhcpcParam->lpr_server->num;
  2514.             for (loop = 0; loop < limit; loop++)
  2515.                 {
  2516.                 bcopy( (char *)&pDhcpcParam->lpr_server->addr [loop],
  2517.                       (char *)&pParamList->lpr_server->addr [loop],
  2518.                       sizeof (struct in_addr));
  2519.                 }
  2520.             }
  2521.         pParamList->lpr_server->num = limit;
  2522.         }
  2524.     if (pParamList->impress_server != NULL &&
  2525.         pDhcpcParam->impress_server != NULL)
  2526.         {
  2527.         limit = 0;
  2528.         if (pParamList->impress_server->addr != NULL)
  2529.             {
  2530.             limit = (pParamList->impress_server->num <
  2531.                      pDhcpcParam->impress_server->num) ?
  2532.                      pParamList->impress_server->num :
  2533.                      pDhcpcParam->impress_server->num;
  2534.             for (loop = 0; loop < limit; loop++)
  2535.                 {
  2536.                 bcopy ( (char *)&pDhcpcParam->impress_server->addr [loop],
  2537.                        (char *)&pParamList->impress_server->addr [loop],
  2538.                        sizeof (struct in_addr));
  2539.                 }
  2540.             }
  2541.         pParamList->impress_server->num = limit;
  2542.         }
  2544.     if (pParamList->rls_server != NULL && pDhcpcParam->rls_server != NULL)
  2545.         {
  2546.         limit = 0;
  2547.         if (pParamList->rls_server->addr != NULL)
  2548.             {
  2549.             limit = (pParamList->rls_server->num <
  2550.                      pDhcpcParam->rls_server->num) ?
  2551.                      pParamList->rls_server->num :
  2552.                      pDhcpcParam->rls_server->num;
  2553.             for (loop = 0; loop < limit; loop++)
  2554.                 {
  2555.                 bcopy ( (char *)&pDhcpcParam->rls_server->addr [loop],
  2556.                        (char *)&pParamList->rls_server->addr [loop],
  2557.                        sizeof (struct in_addr));
  2558.                 }
  2559.             }
  2560.         pParamList->rls_server->num = limit;
  2561.         }
  2563.     if (pParamList->nis_server != NULL && pDhcpcParam->nis_server != NULL)
  2564.         {
  2565.         limit = 0;
  2566.         if (pParamList->nis_server->addr != NULL)
  2567.             {
  2568.             limit = (pParamList->nis_server->num <
  2569.                      pDhcpcParam->nis_server->num) ?
  2570.                      pParamList->nis_server->num :
  2571.                      pDhcpcParam->nis_server->num;
  2572.             for (loop = 0; loop < limit; loop++)
  2573.                 {
  2574.                 bcopy ( (char *)&pDhcpcParam->nis_server->addr [loop],
  2575.                        (char *)&pParamList->nis_server->addr [loop],
  2576.                        sizeof (struct in_addr));
  2577.                 }
  2578.             }
  2579.         pParamList->nis_server->num = limit;
  2580.         }
  2582.     if (pParamList->ntp_server != NULL && pDhcpcParam->ntp_server != NULL)
  2583.         {
  2584.         limit = 0;
  2585.         if (pParamList->ntp_server->addr != NULL)
  2586.             {
  2587.             limit = (pParamList->ntp_server->num <
  2588.                      pDhcpcParam->ntp_server->num) ?
  2589.                      pParamList->ntp_server->num :
  2590.                      pDhcpcParam->ntp_server->num;
  2591.             for (loop = 0; loop < limit; loop++)
  2592.                 {
  2593.                 bcopy ( (char *)&pDhcpcParam->ntp_server->addr [loop],
  2594.                        (char *)&pParamList->ntp_server->addr [loop],
  2595.                        sizeof (struct in_addr));
  2596.                 }
  2597.             }
  2598.         pParamList->ntp_server->num = limit;
  2599.         }
  2601.     if (pParamList->nbn_server != NULL && pDhcpcParam->nbn_server != NULL)
  2602.         {
  2603.         limit = 0;
  2604.         if (pParamList->nbn_server->addr != NULL)
  2605.             {
  2606.             limit = (pParamList->nbn_server->num <
  2607.                      pDhcpcParam->nbn_server->num) ?
  2608.                      pParamList->nbn_server->num :
  2609.                      pDhcpcParam->nbn_server->num;
  2610.             for (loop = 0; loop < limit; loop++)
  2611.                 {
  2612.                 bcopy ( (char *)&pDhcpcParam->nbn_server->addr [loop],
  2613.                        (char *)&pParamList->nbn_server->addr [loop],
  2614.                        sizeof (struct in_addr));
  2615.                 }
  2616.             }
  2617.         pParamList->nbn_server->num = limit;
  2618.         }
  2620.     if (pParamList->nbdd_server != NULL && pDhcpcParam->nbdd_server != NULL)
  2621.         {
  2622.         limit = 0;
  2623.         if (pParamList->nbdd_server->addr != NULL)
  2624.             {
  2625.             limit = (pParamList->nbdd_server->num <
  2626.                      pDhcpcParam->nbdd_server->num) ?
  2627.                      pParamList->nbdd_server->num :
  2628.                      pDhcpcParam->nbdd_server->num;
  2629.             for (loop = 0; loop < limit; loop++)
  2630.                 {
  2631.                 bcopy ( (char *)&pDhcpcParam->nbdd_server->addr [loop],
  2632.                        (char *)&pParamList->nbdd_server->addr [loop],
  2633.                        sizeof (struct in_addr));
  2634.                 }
  2635.             }
  2636.         pParamList->nbdd_server->num = limit;
  2637.         }
  2639.     if (pParamList->xfont_server != NULL &&
  2640.         pDhcpcParam->xfont_server != NULL)
  2641.         {
  2642.         limit = 0;
  2643.         if (pParamList->xfont_server->addr != NULL)
  2644.             {
  2645.             limit = (pParamList->xfont_server->num <
  2646.                      pDhcpcParam->xfont_server->num) ?
  2647.                      pParamList->xfont_server->num :
  2648.                      pDhcpcParam->xfont_server->num;
  2649.             for (loop = 0; loop < limit; loop++)
  2650.                 {
  2651.                 bcopy ( (char *)&pDhcpcParam->xfont_server->addr [loop],
  2652.                        (char *)&pParamList->xfont_server->addr [loop],
  2653.                        sizeof (struct in_addr));
  2654.                 }
  2655.             }
  2656.         pParamList->xfont_server->num = limit;
  2657.         }
  2659.     if (pParamList->xdisplay_manager != NULL &&
  2660.         pDhcpcParam->xdisplay_manager != NULL)
  2661.         {
  2662.         limit = 0;
  2663.         if (pParamList->xdisplay_manager->addr != NULL)
  2664.             {
  2665.             limit = (pParamList->xdisplay_manager->num <
  2666.                      pDhcpcParam->xdisplay_manager->num) ?
  2667.                      pParamList->xdisplay_manager->num :
  2668.                      pDhcpcParam->xdisplay_manager->num;
  2669.             for (loop = 0; loop < limit; loop++)
  2670.                 {
  2671.                 bcopy ( (char *)&pDhcpcParam->xdisplay_manager->addr [loop],
  2672.                        (char *)&pParamList->xdisplay_manager->addr [loop],
  2673.                        sizeof (struct in_addr));
  2674.                 }
  2675.             }
  2676.         pParamList->xdisplay_manager->num = limit;
  2677.         }
  2679.     if (pParamList->nisp_server != NULL && pDhcpcParam->nisp_server != NULL)
  2680.         {
  2681.         limit = 0;
  2682.         if (pParamList->nisp_server->addr != NULL)
  2683.             {
  2684.             limit = (pParamList->nisp_server->num <
  2685.                      pDhcpcParam->nisp_server->num) ?
  2686.                      pParamList->nisp_server->num :
  2687.                      pDhcpcParam->nisp_server->num;
  2688.             for (loop = 0; loop < limit; loop++)
  2689.                 {
  2690.                 bcopy ( (char *)&pDhcpcParam->nisp_server->addr [loop],
  2691.                        (char *)&pParamList->nisp_server->addr [loop],
  2692.                        sizeof (struct in_addr));
  2693.                 }
  2694.             }
  2695.         pParamList->nisp_server->num = limit;
  2696.         }
  2698.     if (pParamList->mobileip_ha != NULL && pDhcpcParam->mobileip_ha != NULL)
  2699.         {
  2700.         limit = 0;
  2701.         if (pParamList->mobileip_ha->addr != NULL)
  2702.             {
  2703.             limit = (pParamList->mobileip_ha->num <
  2704.                      pDhcpcParam->mobileip_ha->num) ?
  2705.                      pParamList->mobileip_ha->num :
  2706.                      pDhcpcParam->mobileip_ha->num;
  2707.             for (loop = 0; loop < limit; loop++)
  2708.                 {
  2709.                 bcopy ( (char *)&pDhcpcParam->mobileip_ha->addr [loop],
  2710.                        (char *)&pParamList->mobileip_ha->addr [loop],
  2711.                        sizeof (struct in_addr));
  2712.                 }
  2713.             }
  2714.         pParamList->mobileip_ha->num = limit;
  2715.         }
  2717.     if (pParamList->smtp_server != NULL && pDhcpcParam->smtp_server != NULL)
  2718.         {
  2719.         limit = 0;
  2720.         if (pParamList->smtp_server->addr != NULL)
  2721.             {
  2722.             limit = (pParamList->smtp_server->num <
  2723.                      pDhcpcParam->smtp_server->num) ?
  2724.                      pParamList->smtp_server->num :
  2725.                      pDhcpcParam->smtp_server->num;
  2726.             for (loop = 0; loop < limit; loop++)
  2727.                 {
  2728.                 bcopy ( (char *)&pDhcpcParam->smtp_server->addr [loop],
  2729.                        (char *)&pParamList->smtp_server->addr [loop],
  2730.                        sizeof (struct in_addr));
  2731.                 }
  2732.             }
  2733.         pParamList->smtp_server->num = limit;
  2734.         }
  2736.     if (pParamList->pop3_server != NULL && pDhcpcParam->pop3_server != NULL)
  2737.         {
  2738.         limit = 0;
  2739.         if (pParamList->pop3_server->addr != NULL)
  2740.             {
  2741.             limit = (pParamList->pop3_server->num <
  2742.                      pDhcpcParam->pop3_server->num) ?
  2743.                      pParamList->pop3_server->num :
  2744.                      pDhcpcParam->pop3_server->num;
  2745.             for (loop = 0; loop < limit; loop++)
  2746.                 {
  2747.                 bcopy ( (char *)&pDhcpcParam->pop3_server->addr [loop],
  2748.                        (char *)&pParamList->pop3_server->addr [loop],
  2749.                        sizeof (struct in_addr));
  2750.                 }
  2751.             }
  2752.         pParamList->pop3_server->num = limit;
  2753.         }
  2755.     if (pParamList->nntp_server != NULL && pDhcpcParam->nntp_server != NULL)
  2756.         {
  2757.         limit = 0;
  2758.         if (pParamList->nntp_server->addr != NULL)
  2759.             {
  2760.             limit = (pParamList->nntp_server->num <
  2761.                      pDhcpcParam->nntp_server->num) ?
  2762.                      pParamList->nntp_server->num :
  2763.                      pDhcpcParam->nntp_server->num;
  2764.             for (loop = 0; loop < limit; loop++)
  2765.                 {
  2766.                 bcopy ( (char *)&pDhcpcParam->nntp_server->addr [loop],
  2767.                        (char *)&pParamList->nntp_server->addr [loop],
  2768.                        sizeof (struct in_addr));
  2769.                 }
  2770.             }
  2771.         pParamList->nntp_server->num = limit;
  2772.         }
  2774.     if (pParamList->dflt_www_server != NULL &&
  2775.         pDhcpcParam->dflt_www_server != NULL)
  2776.         {
  2777.         limit = 0;
  2778.         if (pParamList->dflt_www_server->addr != NULL)
  2779.             {
  2780.             limit = (pParamList->dflt_www_server->num <
  2781.                      pDhcpcParam->dflt_www_server->num) ?
  2782.                      pParamList->dflt_www_server->num :
  2783.                      pDhcpcParam->dflt_www_server->num;
  2784.             for (loop = 0; loop < limit; loop++)
  2785.                 {
  2786.                 bcopy ( (char *)&pDhcpcParam->dflt_www_server->addr [loop],
  2787.                        (char *)&pParamList->dflt_www_server->addr [loop],
  2788.                        sizeof (struct in_addr));
  2789.                 }
  2790.             }
  2791.         pParamList->dflt_www_server->num = limit;
  2792.         }
  2794.     if (pParamList->dflt_finger_server != NULL &&
  2795.         pDhcpcParam->dflt_finger_server != NULL)
  2796.         {
  2797.         limit = 0;
  2798.         if (pParamList->dflt_finger_server->addr != NULL)
  2799.             {
  2800.             limit = (pParamList->dflt_finger_server->num <
  2801.                      pDhcpcParam->dflt_finger_server->num) ?
  2802.                      pParamList->dflt_finger_server->num :
  2803.                      pDhcpcParam->dflt_finger_server->num;
  2804.             for (loop = 0; loop < limit; loop++)
  2805.                 {
  2806.                 bcopy ( (char *)&pDhcpcParam->dflt_finger_server->addr [loop],
  2807.                        (char *)&pParamList->dflt_finger_server->addr [loop],
  2808.                        sizeof (struct in_addr));
  2809.                 }
  2810.             }
  2811.         pParamList->dflt_finger_server->num = limit;
  2812.         }
  2814.     if (pParamList->dflt_irc_server != NULL &&
  2815.         pDhcpcParam->dflt_irc_server != NULL)
  2816.         {
  2817.         limit = 0;
  2818.         if (pParamList->dflt_irc_server->addr != NULL)
  2819.             {
  2820.             limit = (pParamList->dflt_irc_server->num <
  2821.                      pDhcpcParam->dflt_irc_server->num) ?
  2822.                      pParamList->dflt_irc_server->num :
  2823.                      pDhcpcParam->dflt_irc_server->num;
  2824.             for (loop = 0; loop < limit; loop++)
  2825.                 {
  2826.                 bcopy ( (char *)&pDhcpcParam->dflt_irc_server->addr [loop],
  2827.                        (char *)&pParamList->dflt_irc_server->addr [loop],
  2828.                        sizeof (struct in_addr));
  2829.                 }
  2830.             }
  2831.         pParamList->dflt_irc_server->num = limit;
  2832.         }
  2834.     if (pParamList->streettalk_server != NULL &&
  2835.         pDhcpcParam->streettalk_server != NULL)
  2836.         {
  2837.         limit = 0;
  2838.         if (pParamList->streettalk_server->addr != NULL)
  2839.             {
  2840.             limit = (pParamList->streettalk_server->num <
  2841.                      pDhcpcParam->streettalk_server->num) ?
  2842.                      pParamList->streettalk_server->num :
  2843.                      pDhcpcParam->streettalk_server->num;
  2844.             for (loop = 0; loop < limit; loop++)
  2845.                 {
  2846.                 bcopy ( (char *)&pDhcpcParam->streettalk_server->addr [loop],
  2847.                        (char *)&pParamList->streettalk_server->addr [loop],
  2848.                        sizeof (struct in_addr));
  2849.                 }
  2850.             }
  2851.         pParamList->streettalk_server->num = limit;
  2852.         }
  2854.     if (pParamList->stda_server != NULL &&
  2855.         pDhcpcParam->stda_server != NULL)
  2856.         {
  2857.         limit = 0;
  2858.         if (pParamList->stda_server->addr != NULL)
  2859.             {
  2860.             limit = (pParamList->stda_server->num <
  2861.                      pDhcpcParam->stda_server->num) ?
  2862.                      pParamList->stda_server->num :
  2863.                      pDhcpcParam->stda_server->num;
  2864.             for (loop = 0; loop < limit; loop++)
  2865.                 {
  2866.                 bcopy ( (char *)&pDhcpcParam->stda_server->addr [loop],
  2867.                        (char *)&pParamList->stda_server->addr [loop],
  2868.                        sizeof (struct in_addr));
  2869.                 }
  2870.             }
  2871.         pParamList->stda_server->num = limit;
  2872.         }
  2874.     /* Handle multiple IP address pairs. */
  2876.     if (pParamList->policy_filter != NULL &&
  2877.         pDhcpcParam->policy_filter != NULL)
  2878.         {
  2879.         limit = 0;
  2880.         if (pParamList->policy_filter->addr != NULL)
  2881.             {
  2882.             limit = (pParamList->policy_filter->num <
  2883.                      pDhcpcParam->policy_filter->num) ?
  2884.                      pParamList->policy_filter->num :
  2885.                      pDhcpcParam->policy_filter->num;
  2886.             for (loop = 0; loop < limit; loop++)
  2887.                 {
  2888.                 bcopy( (char *)&pDhcpcParam->policy_filter->addr [loop * 2],
  2889.                       (char *)&pParamList->policy_filter->addr [loop * 2],
  2890.                       2 * sizeof (struct in_addr));
  2891.                 }
  2892.             }
  2893.         pParamList->policy_filter->num = limit;
  2894.         }
  2896.     if (pParamList->static_route != NULL &&
  2897.         pDhcpcParam->static_route != NULL)
  2898.         {
  2899.         limit = 0;
  2900.         if (pParamList->static_route->addr != NULL)
  2901.             {
  2902.             limit = (pParamList->static_route->num <
  2903.                      pDhcpcParam->static_route->num) ?
  2904.                      pParamList->static_route->num :
  2905.                      pDhcpcParam->static_route->num;
  2906.             for (loop = 0; loop < limit; loop++)
  2907.                 {
  2908.                 bcopy ( (char *)&pDhcpcParam->static_route->addr [loop * 2],
  2909.                        (char *)&pParamList->static_route->addr [loop * 2],
  2910.                        2 * sizeof (struct in_addr));
  2911.                 }
  2912.             }
  2913.         pParamList->static_route->num = limit;
  2914.         }
  2916.     /* Handle lists. */
  2918.     if (pParamList->vendlist != NULL && pDhcpcParam->vendlist != NULL)
  2919.         {
  2920.         limit = (pParamList->vendlist->len < pDhcpcParam->vendlist->len) ?
  2921.                 pParamList->vendlist->len : pDhcpcParam->vendlist->len;
  2922.         bcopy (pDhcpcParam->vendlist->list, pParamList->vendlist->list,
  2923.                limit);
  2924.         pParamList->vendlist->len = limit;
  2925.         }
  2927.     return;
  2928.     }