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

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

VxWorks

开发平台：

C/C++

dhcpsLib.c：源码内容
  1. /* dhcpsLib.c - Dynamic Host Configuration Protocol (DHCP) server library */
  3. /* Copyright 1984 - 2001 Wind River Systems, Inc.  */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01v,16nov01,spm  fixed modification history
  10. 01u,29oct01,wap  Correct typo in documentation (SPR #34808)
  11. 01t,15oct01,rae  merge from truestack ver 01x, base 01p (VIRTUAL_STACK)
  12. 01s,17nov00,spm  added support for BSD Ethernet devices
  13. 01r,24oct00,spm  fixed modification history after merge from tor3_0_x branch;
  14.                  corrected pathname in library description
  15. 01q,23oct00,niq  merged from version 01t of tor3_0_x branch (base version 01p);
  16.                  upgrade to BPF replaces tagged frames support
  17. 01p,17jan98,kbw  removed NOMANUAL restriction from init function
  18. 01o,17dec97,spm  fixed byte order of address-based loop boundaries (SPR #20056)
  19. 01n,14dec97,kbw  made minor man page fixes
  20. 01m,10dec97,kbw  made minor man page fixes
  21. 01l,04dec97,spm  added code review modifications
  22. 01k,25oct97,kbw  made minor man page fixes
  23. 01j,06oct97,spm  removed reference to deleted endDriver global; replaced with
  24.                  support for dynamic driver type detection
  25. 01i,25sep97,gnn  SENS beta feedback fixes
  26. 01h,26aug97,spm  added code review fixes and support for UDP port selection
  27. 01g,12aug97,gnn  changes necessitated by MUX/END update.
  28. 01f,30jul97,kbw  fixed man page problems found in beta review
  29. 01e,15jul97,spm  allowed startup without lease storage; changed module title
  30. 01d,02jun97,spm  updated man pages and added ERRNO entries
  31. 01c,06may97,spm  changed memory access to align IP header on four byte
  32.                  boundary and corrected cleanup routine
  33. 01b,17apr97,kbw  fixed man page format, changed wording, spell checked doc
  34. 01a,07apr97,spm  created by modifying WIDE project DHCP implementation
  35. */
  37. /*
  38. DESCRIPTION
  39. This library implements the server side of the Dynamic Host Configuration
  40. Protocol (DHCP).  DHCP is an extension of BOOTP.  Like BOOTP, it allows a
  41. target to configure itself dynamically by using the network to get 
  42. its IP address, a boot file name, and the DHCP server's address.  Additionally,
  43. DHCP provides for automatic reuse of network addresses by specifying
  44. individual leases as well as many additional options.  The compatible
  45. message format allows DHCP participants to interoperate with BOOTP
  46. participants.  The dhcpsInit() routine links this library into the VxWorks 
  47. image.  This happens automatically if INCLUDE_DHCPS is defined when the image 
  48. is built.
  50. PRIMARY INTERFACE
  51. The dhcpsInit() routine initializes the server.  It reads the hard-coded server 
  52. configuration data that is stored in three separate tables.
  53. The first table contains entries as follows:
  54. .CS
  55. DHCPS_LEASE_DESC dhcpsLeaseTbl [] =
  56.     {
  57.     {"sample1", "90.11.42.24", "90.11.42.24", "clid=e"1:0x08003D21FE90e""},
  58.     {"sample2", "90.11.42.25", "90.11.42.28", "maxl=90:dfll=60"},
  59.     {"sample3", "90.11.42.29", "90.11.42.34", "maxl=0xffffffff:file=/vxWorks"},
  60.     {"sample4", "90.11.42.24", "90.11.42.24", "albp=true:file=/vxWorks"}
  61.     };
  62. .CE
  63. Each entry contains a name of up to eight characters, the starting and ending 
  64. IP addresses of a range, and the parameters associated with the lease.  The
  65. four samples shown demonstrate the four types of leases. 
  67. Manual leases contain a specific client ID, and are issued only to that client, 
  68. with an infinite duration.  The example shown specifies a MAC address, which is 
  69. the identifier type used by the VxWorks DHCP client.
  71. Dynamic leases specify a finite maximum length, and can be issued to any
  72. requesting client.  These leases allow later re-use of the assigned IP address.
  73. If not explicitly specified in the parameters field, these leases use the 
  74. values of DHCPS_MAX_LEASE and DHCPS_DFLT_LEASE to determine the lease length.
  76. Automatic leases are implied by the infinite maximum length.  Their IP addresses
  77. are assigned permanently to any requesting client.
  79. The last sample demonstrates a lease that is also available to BOOTP clients.
  80. The infinite maximum length is implied, and any timing-related parameters are
  81. ignored. 
  83. The DHCP server supplies leases to DHCP clients according to the lease type in
  84. the order shown above.  Manual leases have the highest priority and leases 
  85. available to BOOTP clients the lowest.
  87. Entries in the parameters field may be one of these types:
  89. .IP `bool' 8
  90. Takes values of "true" or "false", for example, ipfd=true.  Unrecognized 
  91. values default to false. 
  92. .IP 'str'
  93. Takes a character string as a value, for example, hstn="clapton".
  94. If the string includes a delimiter character, such as a colon, it 
  95. should be enclosed in quotation marks.
  96. .IP 'octet'
  97. Takes an 8-bit integer in decimal, octal, or hexadecimal, for example,
  98. 8, 070, 0xff.
  99. .IP 'short'
  100. Takes a 16-bit integer.
  101. .IP 'long'
  102. Takes a 32-bit integer.
  103. .IP 'ip'
  104. Takes a string that is interpreted 
  105. as a 32-bit IP address.  One of the following formats is
  106. expected: a.b.c.d, a.b.c or a.b.  In the second
  107. format, c is interpreted as a 16-bit value.  In
  108. the third format, b is interpreted as a 24-bit
  109. value, for example siad=90.11.42.1.  
  110. .IP 'iplist'
  111. Takes a list of IP addresses, separated by
  112. white space, for example, rout=133.4.31.1 133.4.31.2 133.4.31.3.
  113. .IP 'ippairs'
  114. Takes a list of IP address pairs.  Each IP
  115. address is separated by white space and grouped
  116. in pairs, for example, strt=133.4.27.0  133.4.31.1
  117. 133.4.36.0 133.4.31.1.
  118. .IP 'mtpt'
  119. Takes a list of 16 bit integers,
  120. separated by white space, for example, mtpt=1 2 3 4 6 8.
  121. .IP 'clid'
  122. Takes a client identifier as a value.
  123. Client identifiers are represented by the quoted
  124. string "<type>:<data>", where <type> is an
  125. integer from 0 to 255, as defined by the IANA,
  126. and <data> is a sequence of 8-bit values in hexadecimal.
  127. The client ID is usually a MAC address, for example, 
  128. clid="1:0x08004600e5d5".
  129. .LP
  130. The following table lists the option specifiers and descriptions for
  131. every possible entry in the parameter list.  When available, the option
  132. code from RFC 2132 is included.
  133. .TS
  134. tab(|);
  135. lf3 lf3 lf3 lf3
  136. l   l   l   l.
  137. Name | Code | Type    | Description
  138. _
  139. snam | -    | str     | Optional server name.
  141. file | -    | str     | Name of file containing the boot image.
  143. siad | -    | ip      | Address of server that offers the boot image.
  145. albp | -    | bool    | If true, this entry is also available
  146.      |      |         | to BOOTP clients.  For entries using
  147.      |      |         | static allocation, this value becomes
  148.      |      |         | true by default and <maxl> becomes
  149.      |      |         | infinity.
  151. maxl | -    | long    | Maximum lease duration in seconds. 
  153. dfll | -    | long    | Default lease duration in seconds.  If a
  154.      |      |         | client does not request a specific lease
  155.      |      |         | duration, the server uses this value.
  157. clid | -    | clid    | This specifies a client identifier for
  158.      |      |         | manual leases.  The VxWorks client uses
  159.      |      |         | a MAC address as the client identifier.
  161. pmid | -    | clid    | This specifies a client identifier for
  162.      |      |         | client-specific parameters to be included
  163.      |      |         | in a lease.  It should be present in separate
  164.      |      |         | entries without IP addresses.
  166. clas | -    | str     | This specifies a class identifier for
  167.      |      |         | class-specific parameters to be included in 
  168.      |      |         | a lease.  It should be present in separate entries
  169.      |      |         | without IP addresses.
  171. snmk | 1    | ip      | Subnet mask of the IP address to be
  172.      |      |         | allocated.  The default is a natural mask
  173.      |      |         | corresponding to the IP address.  The
  174.      |      |         | server will not issue IP addresses to 
  175.      |      |         | clients on different subnets.
  177. tmof | 2    | long    | Time offset from UTC in seconds.
  179. rout | 3    | iplist  | A list of routers on the same subnet as
  180.      |      |         | the client.
  182. tmsv |  4   | iplist  | A list of time servers (RFC 868).
  184. nmsv |  5   | iplist  | A list of name servers (IEN 116).
  186. dnsv |  6   | iplist  | A list of DNS servers (RFC 1035).
  188. lgsv |  7   | iplist  | A list of MIT-LCS UDP log servers.
  190. cksv |  8   | iplist  | A list of Cookie servers (RFC 865).
  192. lpsv |  9   | iplist  | A list of LPR servers (RFC 1179).
  194. imsv |  10  | iplist  | A list of Imagen Impress servers.
  196. rlsv |  11  | iplist  | A list of Resource Location servers (RFC 887).
  198. hstn |  12  | str     | Hostname of the client.
  200. btsz |  13  | short   | Size of boot image.
  202. mdmp |  14  | str     | Path name to which client dumps core.
  204. dnsd |  15  | str     | Domain name for DNS.
  206. swsv |  16  | ip      | IP address of swap server.
  208. rpth |  17  | str     | Path name of root disk of the client.
  210. epth |  18  | str     | Extensions Path (See RFC 1533).
  212. ipfd |  19  | bool    | If true, the client performs IP
  213.      |      |         | forwarding.
  215. nlsr |  20  | bool    | If true, the client can perform non-local
  216.      |      |         | source routing.
  218. plcy |  21  | ippairs | Policy filter for non-local source
  219.      |      |         | routing.  A list of pairs of
  220.      |      |         | (Destination IP, Subnet mask).
  222. mdgs |  22  | short   | Maximum size of IP datagram that the
  223.      |      |         | client should be able to reassemble.
  225. ditl |  23  | octet   | Default IP TTL.
  227. mtat |  24  | long    | Aging timeout (in seconds) to be used
  228.      |      |         | with Path MTU discovery (RFC 1191).
  230. mtpt |  25  | mtpt    | A table of MTU sizes to be used with
  231.      |      |         | Path MTU Discovery.
  233. ifmt |  26  | short   | MTU to be used on an interface.
  235. asnl |  27  | bool    | If true, the client assumes that all
  236.      |      |         | subnets to which the client is connected
  237.      |      |         | use the same MTU.
  239. brda |  28  | ip      | Broadcast address in use on the client's
  240.      |      |         | subnet.  The default is calculated from
  241.      |      |         | the subnet mask and the IP address.
  243. mskd |  29  | bool    | If true, the client should perform subnet
  244.      |      |         | mask discovery using ICMP.
  246. msks |  30  | bool    | If true, the client should respond to
  247.      |      |         | subnet mask requests using ICMP.
  249. rtrd |  31  | bool    | If true, the client should solicit
  250.      |      |         | routers using Router Discovery defined
  251.      |      |         | in RFC 1256.
  253. rtsl |  32  | ip      | Destination IP address to which the
  254.      |      |         | client sends router solicitation
  255.      |      |         | requests.
  257. strt |  33  | ippairs | A table of static routes for the client,
  258.      |      |         | which are pairs of (Destination, Router).
  259.      |      |         | It is illegal to specify default route
  260.      |      |         | as a destination.
  262. trlr |  34  | bool    | If true, the client should negotiate
  263.      |      |         | the use of trailers with ARP (RFC 893).
  265. arpt |  35  | long    | Timeout in seconds for ARP cache.
  267. encp |  36  | bool    | If false, the client uses RFC 894
  268.      |      |         | encapsulation.  If true, it uses
  269.      |      |         | RFC 1042 (IEEE 802.3) encapsulation.
  271. dttl |  37  | octet   | Default TTL of TCP.
  273. kain |  38  | long    | Interval of the client's TCP keepalive
  274.      |      |         | in seconds.
  276. kagb |  39  | bool    | If true, the client should send TCP
  277.      |      |         | keepalive messages with a octet of
  278.      |      |         | garbage for compatibility.
  280. nisd |  40  | str     | Domain name for NIS.
  282. nisv |  41  | iplist  | A list of NIS servers.
  284. ntsv |  42  | iplist  | A list of NTP servers.
  286. nnsv |  44  | iplist  | A list of NetBIOS name server.
  287.      |      |         | (RFC 1001, 1002)
  289. ndsv |  45  | iplist  | A list of NetBIOS datagram distribution
  290.      |      |         | servers (RFC 1001, 1002).
  292. nbnt |  46  | octet   | NetBIOS node type (RFC 1001, 1002).
  294. nbsc |  47  | str     | NetBIOS scope (RFC 1001, 1002).
  296. xfsv |  48  | iplist  | A list of font servers of X Window system.
  298. xdmn |  49  | iplist  | A list of display managers of X Window
  299.      |      |         | system.
  301. dht1 |  58  | short   | This value specifies when the client should
  302.      |      |         | start RENEWING.  The default of 500 means
  303.      |      |         | the client starts RENEWING after 50% of the
  304.      |      |         | lease duration passes.
  306. dht2 |  59  | short   | This value specifies when the client should
  307.      |      |         | start REBINDING.  The default of 875 means
  308.      |      |         | the client starts REBINDING after 87.5% of
  309.      |      |         | the lease duration passes.
  310. .TE
  311. .LP
  312. Finally, to function correctly, the DHCP server requires access to some form
  313. of permanent storage.  The DHCPS_LEASE_HOOK constant specifies the name of a 
  314. storage routine with the following interface:
  315. .CS
  316.     STATUS dhcpsStorageHook (int op, char *buffer, int datalen);
  317. .CE
  318. The storage routine is installed by a call to the dhcpsLeaseHookAdd() routine
  319. The manual pages for dhcpsLeaseHookAdd() describe the parameters and required 
  320. operation of the storage routine.
  322. SECONDARY INTERFACE
  323. In addition to the hard-coded entries, address entries may be added after the 
  324. server has started by calling the following routine:
  325. .CS
  326.     STATUS dhcpsLeaseEntryAdd (char *name, char *start, char *end, char *config);
  327. .CE
  328. The parameters specify an entry name, starting and ending values for a block 
  329. of IP addresses, and additional configuration information in the same format 
  330. as shown above for the hard-coded entries.  Each parameter must be formatted 
  331. as a NULL-terminated string. 
  333. The DHCPS_ADDRESS_HOOK constant specifies the name of a storage routine, used 
  334. to preserve address entries added after startup, which has the following 
  335. prototype:
  336. .CS
  337.     STATUS dhcpsAddressStorageHook (int op,
  338.     char *name, char *start, char *end, 
  339.     char *params);
  340. .CE
  341. The storage routine is installed with the dhcpsAddressHookAdd() routine, and 
  342. is fully described in the manual pages for that function.
  344. OPTIONAL INTERFACE
  345. The DHCP server can also receive messages forwarded from different subnets
  346. by a relay agent.  To provide addresses to clients on different subnets, the
  347. appropriate relay agents must be listed in the provided table in usrNetwork.c. 
  348. A sample configuration is:
  349. .CS
  350.     DHCPS_RELAY_DESC dhcpsRelayTbl [] =
  351. {
  352. {"90.11.46.75", "90.11.46.0"}
  353. };
  354. .CE
  355. Each entry in the table specifies the address of a relay agent that will 
  356. transmit the request and the corresponding subnet number.  To issue leases
  357. successfully, the address pool must also contain IP addresses for the 
  358. monitored subnets.
  360. The following table allows a DHCP server to act as a relay agent in 
  361. addition to its default function of processing messages.  It consists of 
  362. a list of IP addresses.
  363. .CS
  364.     DHCP_TARGET_DESC dhcpTargetTbl [] =
  365.  {
  366.  {"90.11.43.2"},
  367.  {"90.11.44.1"}
  368.  };
  369. .CE
  370. Each IP address in this list receives a copy of any client messages
  371. generated on the subnets monitored by the server.
  373. INTERNAL
  374. This library provides a wrapper for the WIDE project DHCP code found in the
  375. directory .../target/src/dhcp, which contains all the message
  376. processing functions.  This module uses the Berkeley Packet Filter services
  377. to intercept incoming DHCP messages and signals their arrival to the WIDE
  378. project code using a shared semaphore.
  380. INCLUDE FILES: dhcpsLib.h
  382. SEE ALSO: RFC 1541, RFC 1533
  383. */
  385. /* includes */
  387. #include "vxWorks.h"
  389. #include "dhcp/copyright_dhcp.h"
  391. #include "stdio.h"
  392. #include "stdlib.h"
  393. #include "netinet/if_ether.h"
  394. #include "netinet/in.h"
  395. #include "netinet/ip.h"
  396. #include "netinet/udp.h"
  397. #include "sys/ioctl.h"
  398. #include "inetLib.h"
  400. #include "end.h"
  401. #include "ipProto.h"
  403. #include "ioLib.h"             /* close() declaration. */
  404. #include "logLib.h"
  405. #include "rngLib.h"
  406. #include "semLib.h"
  407. #include "sockLib.h"
  408. #include "taskLib.h"
  409. #include "muxLib.h"
  411. #include "dhcp/dhcp.h"
  412. #include "dhcp/common.h"
  413. #include "dhcp/hash.h"
  414. #include "dhcp/common_subr.h"
  415. #include "dhcpsLib.h"
  417. #include "bpfDrv.h"
  419. /* defines */
  421. #define _DHCPS_MAX_DEVNAME 26  /* "/bpf/dhcps" + max unit number + vs num */
  423. /* globals for both the regular and virtual stacks */
  425. #ifndef VIRTUAL_STACK
  427. /* globals */
  428. DHCPS_RELAY_DESC *      pDhcpsRelaySourceTbl;
  429. DHCPS_LEASE_DESC * pDhcpsLeasePool;
  431. long    dhcps_dflt_lease; /* Default for default lease length */
  432. long  dhcps_max_lease;  /* Default maximum lease length */
  434. SEM_ID  dhcpsMutexSem;             /* Synchronization for lease entry adds. */
  435. FUNCPTR dhcpsLeaseHookRtn = NULL;  /* Accesses storage for lease bindings. */
  436. FUNCPTR dhcpsAddressHookRtn = NULL; /* Preserves additional address entries. */
  438. int dhcpsMaxSize;  /* Transmit buffer size & largest supported message. */
  439. int dhcpsBufSize;  /* Size of buffer for BPF devices */
  441. IMPORT struct iovec sbufvec[2];            /* send buffer */
  442. IMPORT struct msg dhcpsMsgOut;
  443. IMPORT struct hash_member *reslist;
  444. IMPORT struct hash_member *bindlist;
  445. IMPORT struct hash_tbl nmhashtable;
  446. IMPORT struct hash_tbl iphashtable;
  447. IMPORT struct hash_tbl cidhashtable;
  448. IMPORT struct hash_tbl relayhashtable;
  449. IMPORT struct hash_tbl paramhashtable;
  451. IMPORT char *dhcpsSendBuf;
  452. IMPORT char *dhcpsOverflowBuf;
  454. IMPORT u_short dhcps_port;
  455. IMPORT u_short dhcpc_port;
  456. /* locals */
  458. struct if_info *dhcpsIntfaceList = NULL;
  459. LOCAL BOOL dhcpsInitialized = FALSE;
  461. /* Berkeley Packet Filter instructions for catching DHCP messages. */
  463. LOCAL struct bpf_insn dhcpfilter[] = DHCPS_FILTER_DEFINE;
  465. LOCAL struct bpf_program dhcpread = {
  466.     sizeof (dhcpfilter) / sizeof (struct bpf_insn),
  467.     dhcpfilter
  468.     };
  470. #else
  471. #include "netinet/vsLib.h"
  472. #include "netinet/vsDhcps.h"
  473. #endif  /* VIRTUAL_STACK */
  475. /* forward declarations */
  477. LOCAL STATUS alloc_sbuf (int);
  478. void dhcpsCleanup (int);
  479. void dhcpsFreeResource (struct dhcp_resource *);
  481. IMPORT int resnmcmp();
  482. IMPORT int resipcmp();
  483. IMPORT int eval_symbol (void *, void *);
  485. IMPORT int open_if();
  486. IMPORT STATUS read_addrpool_file (void);
  487. IMPORT void read_server_db (int);
  488. IMPORT int process_entry (struct dhcp_resource *, DHCPS_ENTRY_DESC *);
  489. IMPORT void set_default (struct dhcp_resource *);
  491. /*******************************************************************************
  492. *
  493. * dhcpsInit - set up the DHCP server parameters and data structures
  494. *
  495. * This routine creates the necessary data structures, builds the
  496. * server address pool, retrieves any lease or address information from 
  497. * permanent storage through the user-provided hooks, and initializes the 
  498. * network interfaces for monitoring.  It is called at system startup if 
  499. * INCLUDE_DHCPS is defined at the time the VxWorks image is built.
  500. *
  501. * The <maxSize> parameter specifies the maximum length supported for any
  502. * DHCP message, including the UDP and IP headers and the largest link
  503. * level header for all supported devices. The smallest valid value is
  504. * 576 bytes, corresponding to the minimum IP datagram a host must accept.
  505. * Larger values will allow the server to handle longer DHCP messages.
  506. * 
  507. * RETURNS: OK, or ERROR if could not initialize.
  508. *
  509. */
  511. STATUS dhcpsInit
  512.     (
  513.     DHCPS_CFG_PARAMS  *pDhcpsCfg      /* configuration parameters */
  514.     )
  515.     {
  516.     struct if_info *pIf = NULL;            /* pointer to interface */
  517.     struct ifnet *pCIf = NULL;           /* pointer to current interface */
  518.     char bpfDevName [_DHCPS_MAX_DEVNAME];  /* "/bpf/dhcps" + max unit number */
  519. #ifdef VIRTUAL_STACK
  520.     char temp [_DHCPS_MAX_DEVNAME];
  521. #endif /* VIRTUAL_STACK */
  523.     int bpfDev;
  525.     struct ifreq ifreq;
  526.     struct sockaddr_in send_addr;
  527.     int loop;
  528.     int result;
  529.     STATUS status;
  531.     if (pDhcpsCfg == (DHCPS_CFG_PARAMS  *)NULL)
  532. return (ERROR);
  534. #ifdef VIRTUAL_STACK
  535.     if (dhcpsVsInit () == ERROR)
  536.         return (ERROR);
  537. #endif /* VIRTUAL_STACK */
  539.     /* It must return error, if it is already initialized */
  540.     if (dhcpsInitialized)
  541.         return (ERROR);
  543.     if (pDhcpsCfg->dhcpMaxMsgSize < DFLTDHCPLEN + UDPHL + IPHL)
  544.         return (ERROR);
  546.     if (bpfDrv () == ERROR)
  547.         return (ERROR);
  549.     dhcpsMaxSize = pDhcpsCfg->dhcpMaxMsgSize;
  550.     dhcpsBufSize = pDhcpsCfg->dhcpMaxMsgSize + sizeof (struct bpf_hdr);
  552.     dhcps_dflt_lease = pDhcpsCfg->dhcpsDfltLease;
  553.     dhcps_max_lease = pDhcpsCfg->dhcpsMaxLease;
  555.     dhcpsLeaseHookAdd (pDhcpsCfg->pDhcpsLeaseFunc);
  556.     dhcpsAddressHookAdd (pDhcpsCfg->pDhcpsAddrFunc);
  558. #ifdef VIRTUAL_STACK
  559.     sprintf(temp, "/bpf/vs%d_dhcps", myStackNum );
  560.     if (bpfDevCreate (temp, pDhcpsCfg->numDev, dhcpsBufSize) == ERROR)
  561. #else
  562.     if (bpfDevCreate ("/bpf/dhcps", pDhcpsCfg->numDev, dhcpsBufSize) == ERROR)
  563. #endif /* VIRTUAL_STACK */
  564.         return (ERROR);
  566.     dhcpsMutexSem = semBCreate (SEM_Q_FIFO, SEM_FULL);
  567.     if (dhcpsMutexSem == NULL)
  568.         return (ERROR);
  570.     bzero ( (char *)&ifreq, sizeof (ifreq));
  571.  
  572.     srand (taskIdSelf ());
  574.     /* Validate the MTU size. */
  576.     for (loop = 0; loop < pDhcpsCfg->numDev; loop++)
  577.         {
  578. pCIf = ifunit (pDhcpsCfg->pDhcpsIfTbl[loop].ifName);
  579. if (pCIf == NULL)
  580.     return (ERROR);
  582.         if (pCIf->if_mtu == 0)    /* No MTU size given: not attached? */
  583.             return (ERROR);
  585.         if (pCIf->if_mtu < DHCP_MSG_SIZE)
  586.             return (ERROR);
  587.         }
  589.     /*
  590.      * Alter the filter program to check for the correct length values and
  591.      * use the specified UDP destination port and maximum hop count.
  592.      */
  594.       /* IP length must at least equal a DHCP message with 4 option bytes. */
  595.     dhcpfilter [6].k = (DFLTDHCPLEN - DFLTOPTLEN + 4) + UDPHL + IPHL;
  597.     dhcpfilter [14].k = pDhcpsCfg->dhcpSPort;   /* Use actual destination port in test. */
  599.        /* UDP length must at least equal a DHCP message with 4 option bytes. */
  600.     dhcpfilter [16].k = (DFLTDHCPLEN - DFLTOPTLEN + 4) + UDPHL;
  602.     dhcpfilter [18].k = pDhcpsCfg->dhcpMaxHops;   /* Use real maximum hop count. */
  604.     /* Store the interface control information and get each BPF device. */
  606.     for (loop = 0; loop < pDhcpsCfg->numDev; loop++)
  607.         {
  608. pCIf = ifunit (pDhcpsCfg->pDhcpsIfTbl[loop].ifName);
  609.         pIf = (struct if_info *)calloc (1, sizeof (struct if_info));
  610.         if (pIf == NULL) 
  611.             {
  612.             logMsg ("Memory allocation error.n", 0, 0, 0, 0, 0, 0);
  613.             dhcpsCleanup (1); 
  614.             return (ERROR);
  615.             }
  616.         pIf->buf = (char *)memalign (4, dhcpsBufSize);
  617.         if (pIf->buf == NULL)
  618.             {
  619.             logMsg ("Memory allocation error.n", 0, 0, 0, 0, 0, 0);
  620.             dhcpsCleanup (1); 
  621.             return (ERROR);
  622.             }
  623.         bzero (pIf->buf, dhcpsBufSize);
  625. #ifdef VIRTUAL_STACK
  626.         sprintf (bpfDevName, "/bpf/vs%d_dhcps%d", myStackNum, loop);
  627. #else
  628.         sprintf (bpfDevName, "/bpf/dhcps%d", loop);
  629. #endif /* VIRTUAL_STACK */
  631.         bpfDev = open (bpfDevName, 0, 0);
  632.         if (bpfDev < 0)
  633.             {
  634.             logMsg ("BPF device creation error.n", 0, 0, 0, 0, 0, 0);
  635.             dhcpsCleanup (1);
  636.             return (ERROR);
  637.             }
  639.         /* Enable immediate mode for reading messages. */
  641.         result = 1;
  642.         result = ioctl (bpfDev, BIOCIMMEDIATE, (int)&result);
  643.         if (result != 0)
  644.             {
  645.             logMsg ("BPF device creation error.n", 0, 0, 0, 0, 0, 0);
  646.             dhcpsCleanup (1);
  647.             return (ERROR);
  648.             }
  650.         result = ioctl (bpfDev, BIOCSETF, (int)&dhcpread);
  651.         if (result != 0)
  652.             {
  653.             logMsg ("BPF filter assignment error.n", 0, 0, 0, 0, 0, 0);
  654.             dhcpsCleanup (1);
  655.             return (ERROR);
  656.             }
  658.         sprintf (ifreq.ifr_name, "%s", pDhcpsCfg->pDhcpsIfTbl[loop].ifName );
  660.         result = ioctl (bpfDev, BIOCSETIF, (int)&ifreq);
  661.         if (result != 0)
  662.             {
  663.             logMsg ("BPF interface attachment error.n", 0, 0, 0, 0, 0, 0);
  664.             dhcpsCleanup (1);
  665.             return (ERROR);
  666.             }
  668.         pIf->next = dhcpsIntfaceList;
  669.         dhcpsIntfaceList = pIf;
  671.         /*
  672.          * Fill in device name and hardware address using the information
  673.          * set when the driver attached to the IP network protocol.
  674.          */
  676.         sprintf (pIf->name, "%s", pCIf->if_name);
  677.         pIf->unit = pCIf->if_unit;
  678.         pIf->bpfDev = bpfDev;
  680.         if (muxDevExists (pCIf->if_name, pCIf->if_unit) == FALSE)
  681.             pIf->htype = ETHER;
  682.         else
  683.             pIf->htype = dhcpConvert (pCIf->if_type);
  685.         pIf->hlen = pCIf->if_addrlen;
  687.         bcopy ((char *) ((struct arpcom *)pCIf)->ac_enaddr,
  688.                (char *)&pIf->haddr, pIf->hlen); 
  689.         }
  691.     pDhcpsLeasePool = pDhcpsCfg->pDhcpsLeaseTbl;
  693.     pDhcpsRelaySourceTbl = pDhcpsCfg->pDhcpsRelayTbl;
  695.     pDhcpRelayTargetTbl = pDhcpsCfg->pDhcpsTargetTbl;
  697.     /* read address pool databasae */
  698.     status = read_addrpool_db (pDhcpsCfg->dhcpsLeaseTblSize);
  699.     if (status == ERROR) 
  700.         {
  701.         dhcpsCleanup (2); 
  702.         return (ERROR);
  703.         }
  705.     status = read_addrpool_file ();  /* retrieve additional address entries */
  706.     if (status == ERROR)
  707.         {
  708.         dhcpsCleanup (2); 
  709.         return (ERROR);
  710.         }
  711.     status = read_bind_db ();        /* read binding database */
  712.     if (status == ERROR)
  713.         {
  714.         dhcpsCleanup (3);
  715.         return (ERROR);
  716.         }
  717.     /* read database of relay agents */ 
  718.     if (pDhcpsCfg->dhcpsRelayTblSize != 0)
  719.         read_relay_db (pDhcpsCfg->dhcpsRelayTblSize);
  721.     /* read database of DHCP servers */
  722.     if (pDhcpsCfg->dhcpTargetTblSize != 0)
  723.         read_server_db (pDhcpsCfg->dhcpTargetTblSize);
  725.     /* Always use default ports for client and server. */
  727.     dhcps_port = htons (pDhcpsCfg->dhcpSPort);
  728.     dhcpc_port = htons (pDhcpsCfg->dhcpCPort);
  730.     /* Create a normal socket for sending messages across networks. */
  732.     dhcpsIntfaceList->fd = socket (AF_INET, SOCK_DGRAM, 0);
  733.     if (dhcpsIntfaceList->fd < 0)
  734.         {
  735.         dhcpsCleanup (4); 
  736.         return (ERROR);
  737.         }
  739.     /* Read-only socket: disable receives to prevent buffer exhaustion. */
  741.     result = 0;
  742.     if (setsockopt (dhcpsIntfaceList->fd, SOL_SOCKET, SO_RCVBUF,
  743.                     (char *)&result, sizeof (result)) != 0)
  744.         {
  745.         dhcpsCleanup (5); 
  746.         return (ERROR);
  747.         }
  749.     bzero ( (char *)&send_addr, sizeof (send_addr));
  750.     send_addr.sin_family = AF_INET;
  751.     send_addr.sin_addr.s_addr = htonl (INADDR_ANY);
  752.     send_addr.sin_port = dhcps_port;
  753.     status = bind (dhcpsIntfaceList->fd, (struct sockaddr *) &send_addr, 
  754.                    sizeof (send_addr));
  755.     if (status < 0)
  756.         {
  757.         dhcpsCleanup (5);
  758.         return (ERROR);
  759.         }
  761.     /* Fill in subnet mask and IP address for each monitored interface. */
  763.     pIf = dhcpsIntfaceList;
  764.     while (pIf != NULL)
  765.         { 
  766.         if (open_if (pIf) < 0) 
  767.             {
  768.             dhcpsCleanup (5);
  769.             return (ERROR);
  770.             }
  771.         pIf = pIf->next;
  772.         }
  774.     /* Create buffers for outgoing messages. */
  776.     if (alloc_sbuf (pDhcpsCfg->dhcpMaxMsgSize) != OK)
  777.         {
  778.         logMsg ("Error: Couldn't allocate memory.n", 0, 0, 0, 0, 0, 0);
  779.         dhcpsCleanup (5);  
  780.         return (ERROR);
  781.         }
  783.     dhcpsInitialized = TRUE;
  785.     return (OK);
  786.     }
  788. /*******************************************************************************
  789. *
  790. * dhcpsVsInit - Initializes the Virtual Stack Portion of the code
  791. *
  792. * dhcpsVsInit is used to configure the VS specific portion of the DHCP server.
  793. *
  794. * RETURNS: ERROR if it could not allocate the needed memory
  795. *    OK otherwise
  796. *
  797. * NOMANUAL
  798. */
  800. #ifdef VIRTUAL_STACK
  801. STATUS dhcpsVsInit ()
  802.     {
  803.     struct bpf_insn mydhcpfilter[] = DHCPS_FILTER_DEFINE;
  804.     unsigned char mydhcpsCookie[] = RFC1048_MAGIC;
  806.     if (vsTbl[myStackNum]->pDhcpsGlobals && (dhcpsInitialized == TRUE))
  807.  return (OK);
  809.     /* Allocate memory to the dhcps globals in this virtual stack */
  810.     vsTbl[myStackNum]->pDhcpsGlobals = (VS_DHCPS *) KHEAP_ALLOC (sizeof (VS_DHCPS));
  811.     if (vsTbl[myStackNum]->pDhcpsGlobals == (VS_DHCPS *) NULL)
  812.  return (ERROR);
  814.     bzero ((char *)vsTbl[myStackNum]->pDhcpsGlobals, sizeof (VS_DHCPS));
  816.     /* Copy over filter variables */
  817.     memcpy (dhcpfilter, mydhcpfilter, MAX_DHCPFILTERS * sizeof (struct bpf_insn));
  819.     dhcpread.bf_len = MAX_DHCPFILTERS;
  820.     dhcpread.bf_insns = dhcpfilter;
  822.     /* Copy over the magic cookie */
  823.     memcpy (dhcpCookie, mydhcpsCookie, MAGIC_LEN * sizeof (unsigned char));
  825.     return (OK);
  826.     }
  827. #endif /* VIRTUAL_STACK */
  829. /*******************************************************************************
  830. *
  831. * dhcpsCleanup - remove data structures
  832. * 
  833. * This routine frees all dynamically allocated memory obtained by the DHCP 
  834. * server.  It is called at multiple points before the program exits due to
  835. * an error occurring or manual shutdown.  The checkpoint parameter indicates 
  836. * which data structures have been created.
  837. *
  838. * RETURNS: N/A
  839. *
  840. * ERRNO: N/A
  841. *
  842. * NOMANUAL
  843. */
  845. void dhcpsCleanup 
  846.     (
  847.     int checkpoint  /* Progress identifier indicating created resources */
  848.     )
  849.     {
  850.     int current = 0;
  851.     struct if_info *pIf;
  852.     struct dhcp_resource *  pResData;
  853.     struct hash_member *  pListElem;
  854.     struct hash_member *  pHashElem;
  855.     struct hash_tbl *  pHashTbl;
  856.     struct dhcp_binding *  pBindData;
  857.     struct relay_acl *  pRelayData;
  858.     DHCP_SERVER_DESC *  pSrvData;
  860.     int loop;
  862.     semDelete (dhcpsMutexSem);               /* Checkpoint 0 */
  863.     current++;
  864.     if (current > checkpoint)
  865.         return;
  866.                                              /* Checkpoint 1 */
  867.     if (checkpoint >= 5)     /* Close socket descriptor if present.  */
  868.         close (dhcpsIntfaceList->fd);
  870.     while (dhcpsIntfaceList != NULL)
  871.         {
  872.         pIf = dhcpsIntfaceList;
  873.         if (pIf->buf != NULL)
  874.             {
  875.             if (pIf->bpfDev >= 0)
  876.                 close (pIf->bpfDev);
  877.             free (pIf->buf);
  878.             }
  880.         dhcpsIntfaceList = dhcpsIntfaceList->next;
  881.         free (pIf);
  882.         }
  883.     current++;
  884.     if (current > checkpoint)
  885.         return;
  886.    
  887.     while (reslist != NULL)                  /* Checkpoint 2 */
  888.         {
  889.         pListElem = reslist;
  890.         pResData = pListElem->data;
  891.         reslist = reslist->next;
  892.         dhcpsFreeResource (pResData);
  893.         free (pListElem);
  894.         }
  896.     pHashTbl = &nmhashtable;
  897.     for (loop = 0; loop < HASHTBL_SIZE; loop++)
  898.         {
  899.         pHashElem = (pHashTbl->head) [loop];
  901.         while (pHashElem != NULL)
  902.             {
  903.             pListElem = pHashElem;
  904.             pHashElem = pHashElem->next;
  905.             free (pListElem);
  906.             }
  907.         }
  909.     pHashTbl = &iphashtable;
  910.     for (loop = 0; loop < HASHTBL_SIZE; loop++)
  911.         {
  912.         pHashElem = (pHashTbl->head) [loop];
  914.         while (pHashElem != NULL)
  915.             {
  916.             pListElem = pHashElem;
  917.             pHashElem = pHashElem->next;
  918.             free (pListElem);
  919.             }
  920.         }
  922.     /*
  923.      * For the hash table holding additional parameters, also remove ID 
  924.      * records (i.e. bindings), since these are not added to the bindlist.
  925.      */
  927.     pHashTbl = &paramhashtable;
  928.     for (loop = 0; loop < HASHTBL_SIZE; loop++)
  929.         {
  930.         pHashElem = (pHashTbl->head) [loop];
  932.         while (pHashElem != NULL)
  933.             {
  934.             pListElem = pHashElem;
  935.             if (pHashElem->data != NULL)
  936.                 free (pHashElem->data);
  937.             pHashElem = pHashElem->next;
  938.             free (pListElem);
  939.             }
  940.         }
  941.     current++;                      
  942.     if (current > checkpoint)
  943.         return;
  945.     /* Checkpoint 3 */
  947.     if (dhcpsAddressHookRtn != NULL)
  948.         (* dhcpsAddressHookRtn) (DHCPS_STORAGE_STOP, NULL, NULL, NULL, NULL);
  950.     while (bindlist != NULL)
  951.         {
  952.         pListElem = bindlist;
  953.         pBindData = bindlist->data;
  954.         bindlist = bindlist->next;
  955.         free (pBindData);
  956.         free (pListElem);
  957.         }
  959.     pHashTbl = &cidhashtable;
  960.     for (loop = 0; loop < HASHTBL_SIZE; loop++)
  961.         {
  962.         pHashElem = (pHashTbl->head) [loop];
  964.         while (pHashElem != NULL)
  965.             {
  966.             pListElem = pHashElem;
  967.             pHashElem = pHashElem->next;
  968.             free (pListElem);
  969.             }
  970.         }
  971.     current++;
  972.     if (current > checkpoint)
  973.         return;
  975.     pHashTbl = &relayhashtable;             /* Checkpoint 4 */
  976.     for (loop = 0; loop < HASHTBL_SIZE; loop++)
  977.         {
  978.         pHashElem = (pHashTbl->head) [loop];
  980.         while (pHashElem != NULL)
  981.             {
  982.             pListElem = pHashElem;
  983.             pRelayData = pHashElem->data;
  984.             pHashElem = pHashElem->next;
  985.             free (pRelayData);
  986.             free (pListElem);
  987.             }
  988.         }
  990.     /* Remove elements of circular list created by read_server_db(). */
  992.     pSrvData = pDhcpTargetList;
  993.     for (loop = 0; loop < dhcpNumTargets; loop++)
  994.         {
  995.         pDhcpTargetList = pDhcpTargetList->next;
  996.         free (pSrvData);
  997.         }
  998.     current++;
  999.     if (current > checkpoint)
  1000.         return;
  1002.     /* Checkpoint 5 (close socket) contained in checkpoint 1. */
  1003.     current++;
  1004.     if (current > checkpoint)
  1005.         return;
  1007.     free (dhcpsSendBuf);                     /* Checkpoint 6 */
  1008.     current++;
  1009.     if (current > checkpoint)
  1010.         return;
  1012.     return;
  1013.     }
  1015. /*******************************************************************************
  1016. *
  1017. * void dhcpsFreeResource - remove allocated memory for resource entry
  1018. *
  1019. * This routine removes any dynamically allocated memory used by the given 
  1020. * lease descriptor.  It is called during cleanup before the server shuts down.
  1021. *
  1022. * RETURNS: N/A
  1023. *
  1024. * ERRNO: N/A
  1025. *
  1026. * NOMANUAL
  1027. */
  1029. void dhcpsFreeResource 
  1030.     (
  1031.     struct dhcp_resource *pTarget    /* Pointer to resource to remove */
  1032.     )
  1033.     {
  1034.     if (pTarget->mtu_plateau_table.shorts != NULL)
  1035.         free (pTarget->mtu_plateau_table.shorts);
  1037.     if (pTarget->router.addr != NULL)
  1038.         free (pTarget->router.addr);
  1040.     if (pTarget->time_server.addr != NULL)
  1041.         free (pTarget->time_server.addr);
  1043.     if (pTarget->name_server.addr != NULL)
  1044.         free (pTarget->name_server.addr);
  1046.     if (pTarget->dns_server.addr != NULL)
  1047.         free (pTarget->dns_server.addr);
  1049.     if (pTarget->log_server.addr != NULL)
  1050.         free (pTarget->log_server.addr);
  1052.     if (pTarget->cookie_server.addr != NULL)
  1053.         free (pTarget->cookie_server.addr);
  1055.     if (pTarget->lpr_server.addr != NULL)
  1056.         free (pTarget->lpr_server.addr);
  1058.     if (pTarget->impress_server.addr != NULL)
  1059.         free (pTarget->impress_server.addr);
  1061.     if (pTarget->rls_server.addr != NULL)
  1062.         free (pTarget->rls_server.addr);
  1064.     if (pTarget->nis_server.addr != NULL)
  1065.         free (pTarget->nis_server.addr);
  1067.     if (pTarget->ntp_server.addr != NULL)
  1068.         free (pTarget->ntp_server.addr);
  1070.     if (pTarget->nbn_server.addr != NULL)
  1071.         free (pTarget->nbn_server.addr);
  1073.     if (pTarget->nbdd_server.addr != NULL)
  1074.         free (pTarget->nbdd_server.addr);
  1076.     if (pTarget->xfont_server.addr != NULL)
  1077.         free (pTarget->xfont_server.addr);
  1079.     if (pTarget->xdisplay_manager.addr != NULL)
  1080.         free (pTarget->xdisplay_manager.addr);
  1082.     if (pTarget->nisp_server.addr != NULL)
  1083.         free (pTarget->nisp_server.addr);
  1085.     if (pTarget->mobileip_ha.addr != NULL)
  1086.         free (pTarget->mobileip_ha.addr);
  1088.     if (pTarget->smtp_server.addr != NULL)
  1089.         free (pTarget->smtp_server.addr);
  1091.     if (pTarget->pop3_server.addr != NULL)
  1092.         free (pTarget->pop3_server.addr);
  1094.     if (pTarget->nntp_server.addr != NULL)
  1095.         free (pTarget->nntp_server.addr);
  1097.     if (pTarget->dflt_www_server.addr != NULL)
  1098.         free (pTarget->dflt_www_server.addr);
  1100.     if (pTarget->dflt_finger_server.addr != NULL)
  1101.         free (pTarget->dflt_finger_server.addr);
  1103.     if (pTarget->dflt_irc_server.addr != NULL)
  1104.         free (pTarget->dflt_irc_server.addr);
  1106.     if (pTarget->streettalk_server.addr != NULL)
  1107.         free (pTarget->streettalk_server.addr);
  1109.     if (pTarget->stda_server.addr != NULL)
  1110.         free (pTarget->stda_server.addr);
  1112.     if (pTarget->policy_filter.addr1 != NULL)
  1113.         free (pTarget->policy_filter.addr1);
  1114.     if (pTarget->policy_filter.addr2 != NULL)
  1115.         free (pTarget->policy_filter.addr2);
  1117.     if (pTarget->static_route.addr1 != NULL)
  1118.         free (pTarget->static_route.addr1);
  1119.     if (pTarget->static_route.addr2 != NULL)
  1120.         free (pTarget->static_route.addr2);
  1122.     free (pTarget);
  1124.     return;
  1125.     }
  1127. /*******************************************************************************
  1128. *
  1129. * dhcpsLeaseEntryAdd - add another entry to the address pool
  1130. *
  1131. * This routine allows the user to add new entries to the address pool without
  1132. * rebuilding the VxWorks image.  The routine requires a unique entry name of up
  1133. * to eight characters, starting and ending IP addresses, and a colon-separated 
  1134. * list of parameters.  Possible values for the parameters are listed in the 
  1135. * reference entry for dhcpsLib.  The parameters also determine the type of 
  1136. * lease, which the server uses to determine priority when assigning lease 
  1137. * addresses.  For examples of the possible lease types, see the reference 
  1138. * entry for dhcpsLib.
  1139. *
  1140. * RETURNS: OK if entry read successfully, or ERROR otherwise.
  1141. *
  1142. * ERRNO: N/A
  1143. */
  1145. STATUS dhcpsLeaseEntryAdd
  1146.     (
  1147.     char * pName,  /* name of lease entry */
  1148.     char * pStartIp,  /* first IP address to assign */
  1149.     char *  pEndIp,  /* last IP address in assignment range */
  1150.     char * pParams  /* formatted string of lease parameters */
  1151.     )
  1152.     {
  1153.     struct dhcp_resource *pResData = NULL;
  1154.     DHCPS_ENTRY_DESC entryData;
  1155.     struct hash_member *pListElem = NULL;
  1156.     int result;
  1157.     char tmp [10];  /* sizeof ("tblc=dlft") for host requirements defaults. */
  1158.     char entryName [BASE_NAME + 1];   /* User-given name for address range. */
  1159.     char newName [MAX_NAME + 1];    /* Unique name for each entry in range. */
  1160.     char newAddress [INET_ADDR_LEN];
  1161.     struct in_addr nextAddr;
  1162.     int len;
  1163.     char *pTmp;
  1164.     u_long start = 0;
  1165.     u_long end = 0;
  1166.     u_long loop;
  1167.     u_long limit;
  1169.     /* Ignore bad values for range. */
  1171.     if (pStartIp != NULL && pEndIp == NULL)
  1172.         return (ERROR);
  1174.     if (pStartIp == NULL && pEndIp != NULL)
  1175.         return (ERROR);
  1177.     /* If no address specified, just process parameters once. */
  1179.     if (pStartIp == NULL && pEndIp == NULL)
  1180.         {
  1181.         start = 0;
  1182.         end = 0;
  1183.         }
  1184.     else
  1185.         {
  1186.         start = inet_addr (pStartIp);
  1187.         end = inet_addr (pEndIp);
  1188.         if (start == ERROR || end == ERROR)
  1189.             return (ERROR);
  1190.         }
  1192.     entryData.pName = newName;
  1193.     entryData.pAddress = newAddress;
  1194.     entryData.pParams = pParams;
  1196.     len = strlen (pName);
  1197.     if (len > BASE_NAME)
  1198.         {
  1199.         bcopy (pName, entryName, BASE_NAME);
  1200.         entryName [BASE_NAME] = '';
  1201.         }
  1202.     else
  1203.         {
  1204.         bcopy (pName, entryName, len);
  1205.         entryName [len] = '';
  1206.         }
  1208.     limit = ntohl (end);
  1209.     for (loop = ntohl (start); loop <= limit; loop++)
  1210.         {
  1211.         pResData = (struct dhcp_resource *)calloc (1, 
  1212.                                                 sizeof (struct dhcp_resource));
  1213.         if (pResData == NULL)
  1214.             {
  1215.             return (ERROR);
  1216.             }
  1218.         /* Generate a unique name by appending IP address value. */
  1220.         sprintf (entryData.pName, "%s%lx", entryName, loop);
  1222.         /* Assign current IP address in range. */
  1224.         nextAddr.s_addr = htonl (loop);
  1225.         inet_ntoa_b (nextAddr, entryData.pAddress);
  1227.         /* Critical section with message processing routines. */ 
  1229.         semTake (dhcpsMutexSem, WAIT_FOREVER);
  1230.  
  1231.         if (process_entry (pResData, &entryData) < 0)
  1232.             {
  1233.             semGive (dhcpsMutexSem);
  1234.             dhcpsFreeResource (pResData);
  1235.             return (ERROR);
  1236.             }
  1238.         /* 
  1239.          * Add Host Requirements defaults to resource entry. Do not add
  1240.          * to entries containing client-specific or class-specific 
  1241.          * parameters. 
  1242.          */
  1244.         if (ISCLR (pResData->valid, S_PARAM_ID) &&
  1245.             ISCLR (pResData->valid, S_CLASS_ID))
  1246.             {
  1247.             sprintf (tmp, "%s", "tblc=dflt");
  1248.             pTmp = tmp;
  1249.             eval_symbol (&pTmp, pResData);
  1250.             }
  1252.         /* Set default values for entry, if not already assigned. */
  1254.         if (ISSET (pResData->valid, S_IP_ADDR))
  1255.             set_default (pResData);
  1257.         /*
  1258.          * Append entries to lease descriptor list. Exclude entries which
  1259.          * specify additional client- or class-specific parameters.
  1260.          */
  1262.         if (ISCLR (pResData->valid, S_PARAM_ID) && 
  1263.             ISCLR (pResData->valid, S_CLASS_ID))
  1264.             {
  1265.             pListElem = reslist;
  1266.             while (pListElem->next != NULL)
  1267.                 pListElem = pListElem->next; 
  1268.    
  1269.             pListElem->next =
  1270.                  (struct hash_member *)calloc (1, sizeof (struct hash_member));
  1271.             if (pListElem->next == NULL)
  1272.                 {
  1273.                 semGive (dhcpsMutexSem);
  1274.                 dhcpsFreeResource (pResData);
  1275.                 return (ERROR);
  1276.                 }
  1277.             pListElem = pListElem->next;
  1278.             pListElem->next = NULL;
  1279.             pListElem->data = (void *)pResData;
  1281.             /* Add entryname to appropriate hash table. */
  1283.             result = hash_ins (&nmhashtable, pResData->entryname, 
  1284.                                strlen (pResData->entryname), resnmcmp, 
  1285.                                pResData->entryname, pResData);
  1286.             if (result < 0)
  1287.                 {
  1288.                 semGive (dhcpsMutexSem);
  1289.                 return (ERROR);
  1290.                 }
  1292.             if (ISSET (pResData->valid, S_IP_ADDR))
  1293.                 if (hash_ins (&iphashtable, (char *)&pResData->ip_addr.s_addr,
  1294.                               sizeof (u_long), resipcmp, &pResData->ip_addr, 
  1295.                               pResData) < 0)
  1296.                     {
  1297.                     semGive (dhcpsMutexSem);
  1298.                     return (ERROR);
  1299.                     }
  1300.             }
  1302.         semGive (dhcpsMutexSem);
  1303.         }
  1305.     /* Save entry in permanent storage, if hook is provided. */
  1307.     if (dhcpsAddressHookRtn != NULL)
  1308.         (* dhcpsAddressHookRtn) (DHCPS_STORAGE_WRITE, pName,
  1309.                                  pStartIp, pEndIp, pParams);
  1311.     return (OK);
  1312.     }
  1314. /*******************************************************************************
  1315. * 
  1316. * dhcpsLeaseHookAdd - assign a permanent lease storage hook for the server
  1317. * 
  1318. * This routine allows the server to access some form of permanent storage
  1319. * that it can use to store current lease information across restarts.  The 
  1320. * only argument to dhcpsLeaseHookAdd() is a pointer to a storage routine 
  1321. * with the following interface: 
  1322. * .CS
  1323. *     STATUS dhcpsStorageHook (int op, char *buffer, int datalen);
  1324. * .CE
  1325. * The first parameter of the storage routine specifies one of the following 
  1326. * operations: 
  1327. * 
  1328. *     DHCPS_STORAGE_START
  1329. *     DHCPS_STORAGE_READ
  1330. *     DHCPS_STORAGE_WRITE
  1331. *     DHCPS_STORAGE_STOP
  1332. *     DHCPS_STORAGE_CLEAR
  1333. * 
  1334. * In response to START, the storage routine should prepare to return data or 
  1335. * overwrite data provided by earlier WRITEs.  For a WRITE the storage routine 
  1336. * must save the contents of the buffer to permanent storage.  For a READ, the 
  1337. * storage routine should copy data previously stored into the provided buffer 
  1338. * as a NULL-terminated string in FIFO order.  For a CLEAR, the storage routine 
  1339. * should discard currently stored data.  After a CLEAR, the READ operation
  1340. * must return ERROR until additional data is stored.  For a STOP, the storage 
  1341. * routine must handle cleanup.  After a STOP, READ and WRITE operations must
  1342. * return error until a START is received.  Each of these operations must 
  1343. * return OK if successful, or ERROR otherwise.
  1344. * 
  1345. * Before the server is initialized, VxWorks automatically calls 
  1346. * dhcpsLeaseHookAdd(), passing in the routine name defined by DHCPS_LEASE_HOOK.
  1347. * 
  1348. * RETURNS: OK, or ERROR if routine is NULL.
  1349. * 
  1350. * ERRNO: N/A
  1351. */
  1353. STATUS dhcpsLeaseHookAdd
  1354.     (
  1355.     FUNCPTR pCacheHookRtn  /* routine to store/retrieve lease records */
  1356.     )
  1357.     {
  1358.     if (pCacheHookRtn != NULL)
  1359.         {
  1360.         dhcpsLeaseHookRtn = pCacheHookRtn;
  1361.         return (OK);
  1362.         }
  1363.     return (ERROR);
  1364.     }
  1366. /*******************************************************************************
  1367. *
  1368. * dhcpsAddressHookAdd - assign a permanent address storage hook for the server
  1369. *
  1370. * This routine allows the server to access some form of permanent storage
  1371. * to preserve additional address entries across restarts.  This routine is
  1372. * not required, but leases using unsaved addresses are not renewed.  The 
  1373. * only argument provided is the name of a function with the following interface:
  1374. * .CS
  1375. *     STATUS dhcpsAddressStorageHook (int op,
  1376. *                                     char *name, char *start, char *end, 
  1377. *                                     char *params);
  1378. * .CE
  1379. * The first parameter of this storage routine specifies one of the following 
  1380. * operations: 
  1381. *
  1382. *     DHCPS_STORAGE_START
  1383. *     DHCPS_STORAGE_READ
  1384. *     DHCPS_STORAGE_WRITE
  1385. *     DHCPS_STORAGE_STOP 
  1386. *
  1387. * In response to a START, the storage routine should prepare to return
  1388. * data or overwrite data provided by earlier WRITE operations.  For a 
  1389. * WRITE, the storage routine must save the contents of the four buffers 
  1390. * to permanent storage.  Those buffers contain the NULL-terminated 
  1391. * strings received by the dhcpsLeaseEntryAdd() routine.  For a READ, the
  1392. * storage routine should copy previously stored data (as NULL-terminated 
  1393. * strings) into the provided buffers in the order received by earlier WRITE
  1394. * operations.  For a STOP, the storage routine should do any necessary cleanup. 
  1395. * After a STOP, the storage routine should return an ERROR for all operations 
  1396. * except START.  However, the STOP operation does not normally occur since
  1397. * the server only deliberately exits following an unrecoverable error.  This
  1398. * storage routine must not rely on that operation to handle READ, WRITE, or
  1399. * new START attempts.
  1400. * 
  1401. * The storage routine should return OK if successful, ERROR otherwise.
  1402. *
  1403. * Note that, unlike the lease storage routine, there is no CLEAR operation.
  1404. *
  1405. * Before the server is initialized, VxWorks calls this routine automatically 
  1406. * passing in the function named in DHCPS_ADDRESS_HOOK.
  1407. *
  1408. * RETURNS: OK, or ERROR if function pointer is NULL.
  1409. *
  1410. * ERRNO: N/A
  1411. */
  1413. STATUS dhcpsAddressHookAdd
  1414.     (
  1415.     FUNCPTR pCacheHookRtn  /* routine to store/retrieve lease entries */
  1416.     )
  1417.     {
  1418.     /* 
  1419.      * The hook routine is deliberately assigned before testing for NULL
  1420.      * so that this routine can be used to delete an existing address hook.
  1421.      * In that case, the user would just ignore the return value of ERROR.
  1422.      */
  1424.     dhcpsAddressHookRtn = pCacheHookRtn;
  1425.     if (pCacheHookRtn == NULL)
  1426.         return (ERROR);
  1427.     return (OK);
  1428.     }
  1430. /*******************************************************************************
  1431. *
  1432. * alloc_sbuf - create message transmission buffers
  1433. *
  1434. * This routine creates two transmission buffers for storing outgoing DHCP
  1435. * messages.  The first buffer has a fixed size equal to that of a standard 
  1436. * DHCP message as defined in the RFC.  The second buffer contains the
  1437. * remaining number of bytes needed to send the largest supported message.
  1438. * That buffer is only used if additional space for DHCP options is needed
  1439. * and if the requesting client accepts larger DHCP messages.  The two buffers
  1440. * are stored in a global "buffer vector" structure and are also accessible
  1441. * through individual global variables.
  1442. * 
  1443. * RETURNS: N/A
  1444. * 
  1445. * ERRNO: N/A
  1446. *
  1447. * NOMANUAL
  1448. */
  1450. LOCAL STATUS alloc_sbuf
  1451.     (
  1452.     int  maxSize  /* largest supported message size, in bytes */
  1453.     )
  1454.     {
  1455.     char *pSendBuf;
  1456.     int sbufsize;
  1458.     /*
  1459.      * Allocate transmission buffer using aligned memory to provide 
  1460.      * IP header alignment needed by Sun BSP's. 
  1461.      */
  1463.     sbufsize = IPHL + UDPHL + DFLTDHCPLEN;
  1464.     pSendBuf = (char *)memalign (4, maxSize);
  1465.     if (pSendBuf == NULL)
  1466.         return (-1);
  1468.     dhcpsSendBuf = pSendBuf;    /* Buffer for default DHCP message. */
  1469.     bzero (dhcpsSendBuf, sbufsize);
  1471.     sbufvec[0].iov_len = IPHL + UDPHL + DFLTDHCPLEN;
  1473.     sbufvec[0].iov_base = dhcpsSendBuf;
  1474.     dhcpsMsgOut.ip = (struct ip *)dhcpsSendBuf;
  1475.     dhcpsMsgOut.udp = (struct udphdr *)&dhcpsSendBuf [IPHL];
  1476.     dhcpsMsgOut.dhcp = (struct dhcp *)&dhcpsSendBuf [IPHL + UDPHL];
  1478.     dhcpsOverflowBuf = &pSendBuf [sbufsize];  /* Buffer for larger messages */
  1479.     sbufvec[1].iov_base = dhcpsOverflowBuf;
  1480.     sbufvec[1].iov_len = 0;   /* Contains length of bytes in use, not size. */
  1482.     return (OK);
  1483.     }