dhcpv6-1.0/004070000015740003721000000000000625221616300127705ustar00yunzhouip00000400000004dhcpv6-1.0/COPYING010060000015740003721000000430760625233634200140360ustar00yunzhouip00000400000004 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. ect code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense dhcpv6-1.0/Makefile010060000015740003721000000045600625233634200144360ustar00yunzhouip00000400000004# # Makefile file # CFLAGS = -Wall -Wno-strict-prototypes -O2 -fomit-frame-pointer CFLAGS := $(CFLAGS) -I/sys CFLAGS := $(CFLAGS) -DINET6 -DDH6_DEBUG -DNETBSD -DDH6_DB CFLAGS := $(CFLAGS) -fenum-int-equiv CC = gcc -I$(INET) CLINK = DHCPV6 = u_timer.o u_buf.o utils.o dispatch.o inettrans.o \ dh6.o ext6.o sock.o CLIENT = dh6_cli.o su_cli.o dh6_if.o cli_boot.o cli_conf.o parse.o dh6_db.o RELAY = dh6_rly.o dh6_if.o rly_conf.o parse.o SERVER = dh6_svr.o dh6_if.o svr_assign.o svr_conf.o svr_db.o parse.o dh6_db.o DEP = dh6.h dh6_adm.h sock.h u_buf.h u_timer.h dispatch.h ext6.h \ localdefs.h dh6_if.h parse.h .c.o: $(CC) $(CFLAGS) -c -o $*.o $< # DHCPv6 Client Daemon dh6cd: $(DHCPV6) $(CLIENT) $(DEP) dh6_cli.h $(CC) $(CFLAGS) $(DHCPV6) $(CLIENT) $(CLINK) -o dh6cd # DHCPv6 Client Command dh6cc: $(DHCPV6) dh6_clicmd.o dh6_if.o $(DEP) dh6_cli.h $(CC) $(CFLAGS) $(DHCPV6) dh6_clicmd.o dh6_if.o $(CLINK) -o dh6cc # DHCPv6 Server Daemon dh6sd: $(DHCPV6) $(SERVER) $(DEP) dh6_svr.h $(CC) $(CFLAGS) $(DHCPV6) $(SERVER) $(CLINK) -o dh6sd # DHCPv6 Server Command dh6sc: $(DHCPV6) dh6_svrcmd.o dh6_if.o $(DEP) dh6_svr.h $(CC) $(CFLAGS) $(DHCPV6) dh6_svrcmd.o dh6_if.o $(CLINK) -o dh6sc # DHCPv6 Relay Daemon dh6rd: $(DHCPV6) $(RELAY) $(DEP) dh6_rly.h $(CC) $(CFLAGS) $(DHCPV6) $(RELAY) $(CLINK) -o dh6rd # DHCPv6 Relay Command dh6rc: $(DHCPV6) dh6_rlycmd.o dh6_if.o $(DEP) dh6_rly.h $(CC) $(CFLAGS) $(DHCPV6) dh6_rlycmd.o dh6_if.o $(CLINK) -o dh6rc install: dh6cd dh6cc dh6sd dh6sc dh6rd dh6rc test -d /usr/local/etc/dhcpv6 || mkdir /usr/local/etc/dhcpv6 test -r /etc/dh6_client.conf || \ install -m644 dh6_client.conf /etc/dh6_client.conf test -r /etc/dh6_server.conf || \ install -m644 dh6_server.conf /etc/dh6_server.conf test -r /etc/dh6_server.conf || \ install -m644 dh6_relay.conf /etc/dh6_relay.conf install -s -m744 dh6cd /usr/local/etc/dhcpv6/dh6cd install -s -m744 dh6cc /usr/local/bin/dh6cc install -s -m744 dh6sd /usr/local/etc/dhcpv6/dh6sd install -s -m744 dh6sc /usr/local/bin/dh6sc install -s -m744 dh6rd /usr/local/etc/dhcpv6/dh6rd install -s -m744 dh6rc /usr/local/bin/dh6rc install -m644 dh6cc.8 /usr/man/man8/dh6cc.8 install -m644 dh6sc.8 /usr/man/man8/dh6sc.8 install -m644 dh6rc.8 /usr/man/man8/dh6rc.8 clean: rm -f *.o *~ \ timer dh6cd dh6cc dh6sd dh6sc dh6rd dh6rc all: make dh6cd make dh6cc make dh6sd make dh6sc make dh6rd make dh6rc dhcpv6-1.0/README010060000015740003721000000123530625233634200136550ustar00yunzhouip00000400000004Dynamic Host Configuration Protocol For IPv6 Version: @(#)README 1.0 08-Dec-96 This module is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed WITHOUT ANY WARRANTY and even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Many thanks to Jim Bound in Digital Equipment Corp. Appreciate any further work on this release. Author: Yunzhou Li (yunzhou@iol.unh.edu) 1. Introduction This is an implementation of Dynamic Host Configuration Protocol for IPv6 on NetBSD, which is supported by Digital Equipment Corp. (DEC), University of New Hampshire (UNH) and National University of Singapore (NUS). This implementation benefits from UNH's IPv6 implementation by Quaizar Vohra. The purpose of this implementation is to verify the feasibility of DHCPv6 and Extensions for DHCPv6 protocols. Hopefully, the code can be useful for the further development of these two protocols and other research on IPv6. 2. Installation To install this software, please make sure you are working on the top of UNH IPv6 stack (you might port this code to other platforms by slightly changing the code and especially compat.h). Unpack the package dhcpv6-1.0.tar.gz or dhcpv6-1.0.tar.Z by gunzip dhcpv6-1.0.tar.gz OR uncompress dhcpv6-1.0.tar.Z and then tar -xvf dhcpv6-1.0.tar Enter the dhcpv6-1.0 directory, and make all make install Before running the software, you should edit the file /etc/dh6_newaddress and fill out all blocks of IPv6 addresses you can provide for DHCPv6 clients at server. You might also need to change the "MulticastAddr" option in /etc/dh6_server.conf. For client, relay agent and server, there are daemons and command programs, which are, respectively, dh6cd dh6cc dh6rd dh6rc dh6sd dh6sc Daemons are placed at /usr/local/etc/dhcpv6 and activated by command programs. The usages of these command programs can be figured out from man pages. To start and stop dh6cd daemon, for example, your can type dh6cc start dh6cc stop 3. Coding Coordination 3.1 Common Routines u_timer.c specifies how a timer works. It also schedules some other tasks. dispatch.c checks every socket and sees if any incoming messages. u_buf.c defines a specific buffer structure, which is convenient for buffer operations. If one has his individual structure, one can union it in u_buf.h, and then is able to use all the routines in u_buf.c. dh6.c and ext.c are routines for the protocols, which are implementation independent. Please update these two modules with the version-to-version change of the DHCPv6 and its extesions protocols. Some socket operations are defined in sock.c. Routines relevant to interface are defined in dh6_if.c. parse.c is used for analysing configuration files. dh6_db.c includes database operation routines using "dbopen()" and its library. 3.2 Routines for Client There are two levels of processes. The general one is defined in su_cli.c. This general one can fork a child process for a specific interface if Router Avertsement requires DHCPv6 work on the interface. The child process is defined in dh6_cli.c. dh6_cli.c reflects all the protocol behaviours for client. cli_boot.c reads client boot file "dh6_client.boot" and reloads original configuration saved before rebooting. cli_conf.c is a module for client configuration from "dh6_client.conf". dh6_clicmd.c is client command program. It sends adminstrative messages to su_cli.c or dh6_cli.c. 3.3 Routines for Server The main program for server daemon is dh6_svr.c, which implements all the protocol behaviours for server. svr_db.c handles database transactions specific to the server. In svr_assign.c, address allocation mechanism is implemented. svr_conf.c is a module for server configuration from "dh6_server.conf". dh6_svrcmd.c is server command program. It sends adminstrative messages to dh6_svr.c. 3.4 Routines for Relay Agent The main program for relay daemon is dh6_rly.c, which implements all the protocol behaviours for relay agent. rly_conf.c is a module for relay configuration from "dh6_relay.conf". dh6_rlycmd.c is relay command program. It sends adminstrative messages to dh6_rly.c. 4. Debugging The system provides five classes of debugging information, which are packet transmission, system cache, database and file operation, dispatching, and timing. Please refer to utils.c and there are pairs of routines, which are, respectively, look_xmit() look_xmit_more() look_cache() look_cache_more() look_db() look_db_more() look_dp() look_dp_more() look_tm() look_tm_more() You can look into relevant information by dh6cc start -d1 dh6cc start -d6 dh6cc start -d2 dh6cc start -d7 dh6cc start -d3 dh6cc start -d8 dh6cc start -d4 dh6cc start -d9 dh6cc start -d5 dh6cc start -d10 You can change these routines and display the debugging information in your favourite way. Yunzhou Li ( yunzhou@iol.unh.edu) dhcpv6-1.0/TODO010060000015740003721000000011340625233634200134600ustar00yunzhouip00000400000004Would appreciate it if any one could work on some/all of the following: 1. Test the code for relay agent. Do change it if necessary. 2. Build and test all the extensions except for the IPv6 Address extension and Reconfigure Multicast Address extension. 3. If advanced API is finished in the kernel, reduce the number of sockets. It is too expensive to open a socket and use it for quite a long time. 4. Design and build administrative commands. 5. Complete all the "#ifdef TODO" and "TODO" comments in the code. 6. Port to other platforms such as Linux. Yunzhou Li (yunzhou@iol.unh.edu) dhcpv6-1.0/cli_boot.c010060000015740003721000000141060625233634200147310ustar00yunzhouip00000400000004/* * cli_boot.c DHCPv6 Client Reboot Program * * Version: @(#)cli_boot.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_adm.h" #include "dh6_db.h" #include "parse.h" #include "dh6_if.h" #include "dh6_cli.h" extern UNION_LIST server_list, relay_list, client_list; extern IF_INFO *this_ifi; int read_dh6_client_boot( void ) { DB *db; DBT key, rec; struct cli_ifaddr *cia; if ( (db=dh6db_open(DH6CLI_BOOT)) == NULL) log_sys(1501, "dbopen error"); if ((cia=cia_create()) == NULL) return -1; memset(&key, 0, sizeof(key)); key.size = KPREFIX_LEN; key.data = &key_prefix; db->seq(db, &key, &rec, R_CURSOR); if (rec.size < sizeof(struct cli_record)) { cia_destroy(cia); dh6db_close(db); return 0; } dh6db_convert_rec(&rec, cia); do { u_queue_tail(&client_list, cia); if ((cia=cia_create()) == NULL) return -1; } while (dh6db_skip_next(db, cia) == 0); cia_destroy(cia); dh6db_close(db); return 0; } /* * Be careful!!! The length of a key should be multiple of 16! */ int dh6db_alloc_key(DBT *key, void *entry) { struct cli_ifaddr *cia = entry; key->size = 2*IPV6_ADDR_LEN; key->data = malloc(key->size); dh6db_copy(key->data, ifi_lladdr(cia->cia_ifi), IPV6_ADDR_LEN); dh6db_copy(((u_int8_t *)key->data)+IPV6_ADDR_LEN, &cia->cia_rly->cr_addr, IPV6_ADDR_LEN); } int dh6db_alloc_rec(DBT *rec, void *entry) { struct cli_ifaddr *cia = entry; struct cli_record *crec; struct timeval tv; rec->size = sizeof(struct cli_record); rec->data = malloc(rec->size); crec = rec->data; strcpy(crec->ifname, ifi_ifname(cia->cia_ifi)); dh6db_copy(&crec->svr, &cia->cia_svr->cs_addr, IPV6_ADDR_LEN); dh6db_copy(&crec->rly, &cia->cia_rly->cr_addr, IPV6_ADDR_LEN); /* * Very dependent on the structures * struct cli_ifaddr and struct cli_record !!! */ dh6db_copy(&crec->addr, &cia->cia_addr, sizeof(struct cli_record) - 2*IPV6_ADDR_LEN -IFNAMSIZ); gettimeofday(&tv,NULL); crec->req_life = crec->req_life*DH6_LIFETIME_UNIT + tv.tv_sec; crec->prefer_life = crec->prefer_life*DH6_LIFETIME_UNIT + tv.tv_sec; crec->valid_life = crec->valid_life*DH6_LIFETIME_UNIT + tv.tv_sec; } int dh6db_convert_rec(DBT *rec, void *entry) { struct cli_ifaddr *cia = entry; struct cli_server *cs = NULL; struct cli_relay *cr = NULL; struct cli_record *crec = rec->data; struct timeval tv; IF_INFO *ifi; if (rec->data == NULL || rec->size == 0) { log_warn(1515, "Record is NULL"); return -1; } ifi = seek_ifi_byname(crec->ifname, strlen(crec->ifname)); if (ifi != this_ifi) return 1; cia->cia_ifi = this_ifi; if ((cs=cs_get(&crec->svr)) == NULL) { if ((cs=cs_create()) == NULL) return -1; dh6db_copy(&cs->cs_addr,&crec->svr,IPV6_ADDR_LEN); cs->cs_rly = NULL; u_queue_head(&server_list, cs); } if ((cr=cr_get(&crec->rly)) == NULL) { if ((cr=cr_create()) == NULL) return -1; dh6db_copy(&cr->cr_addr,&crec->rly,IPV6_ADDR_LEN); cr->cr_issvr = NULL; u_queue_head(&relay_list, cr); } /* * Very dependent on the structures * struct cli_ifaddr and struct cli_record !!! */ dh6db_copy(&cia->cia_addr, &crec->addr, sizeof(struct cli_record) - 2*IPV6_ADDR_LEN -IFNAMSIZ); gettimeofday(&tv,NULL); cia->cia_req_life = (cia->cia_req_life - tv.tv_sec) / DH6_LIFETIME_UNIT; cia->cia_prefer_life = (cia->cia_prefer_life - tv.tv_sec) / DH6_LIFETIME_UNIT; cia->cia_valid_life = (cia->cia_valid_life - tv.tv_sec) / DH6_LIFETIME_UNIT; cs->cs_rly = cr; if ( cr != NULL && cs != NULL && !memcmp(&cr->cr_addr, &cs->cs_addr, IPV6_ADDR_LEN) ) cr->cr_issvr = cs; } int cli_print_record(struct cli_record *rec) { log_info("DB record: "); log_info(" ifname:%s, server: %s", rec->ifname, inet_ntop(AF_INET6, &rec->svr, 16, NULL)); log_info(" agent: %s", inet_ntop(AF_INET6, &rec->rly, 16, NULL)); log_info(" client: %s", inet_ntop(AF_INET6, &rec->addr, 16, NULL)); log_info(" id:%d, prefix:%d, state:%d, req:%ld, prefer:%ld, valid:%ld", rec->id, rec->prfsize, rec->state, rec->req_life, rec->prefer_life, rec->valid_life); } int cli_dbshow_adm( ADM_MESSAGE *msg, int len ) { DB *db; DBT key, rec; struct cli_record srec; /* at the moment just show all the records */ log_info("Client DB %s:", DH6CLI_BOOT); if ( (db=dh6db_open(DH6CLI_BOOT)) == NULL) log_sys(1501, "dbopen error"); memset(&key, 0, sizeof(key)); key.size = KPREFIX_LEN; key.data = &key_prefix; db->seq(db, &key, &rec, R_CURSOR); do { if (rec.size < sizeof(struct cli_record)) break; dh6db_copy(&srec, rec.data, sizeof(struct cli_record)); cli_print_record(&srec); } while (db->seq(db, &key, &rec, R_NEXT) == 0); dh6db_close(db); return 0; } dhcpv6-1.0/cli_conf.c010060000015740003721000000053710625233634200147170ustar00yunzhouip00000400000004/* * cli_conf.c DHCPv6 Client Configuration * * Version: @(#)cli_conf.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_adm.h" #include "dh6_db.h" #include "parse.h" #include "dh6_if.h" #include "dh6_cli.h" extern int SolicitPbit; extern int SolicitCbit; extern int RequestLife; extern int RequestQbit; int read_dh6_client_conf( void ) { char fname[60]; char buf[100]; int type; FILE *f; sprintf(fname, "%s%s", CLI_CONF_PATH, DH6CLI_CONF); if ((f=fopen(fname, "r+")) == NULL) log_sys(1401, "fopen"); rewind(f); parse_init(); do { type = get_next_token(f, buf); switch (type) { case CLI_SOLICIT_PBIT: type = get_next_token(f, buf); if (type & DIGIT) { SolicitPbit = atoi(buf); continue; } log_warn(1402, "incorrect SolicitPbit format"); break; case CLI_SOLICIT_CBIT: type = get_next_token(f, buf); if (type & DIGIT) { SolicitCbit = atoi(buf); continue; } log_warn(1403, "incorrect SolicitCbit format"); break; case CLI_REQUEST_LIFE: type = get_next_token(f, buf); if (type & DIGIT) { RequestLife = atoi(buf); continue; } log_warn(1404, "incorrect RequestLife format"); break; case CLI_REQUEST_QBIT: type = get_next_token(f, buf); if (type & DIGIT) { RequestQbit = atoi(buf); continue; } log_warn(1405, "incorrect RequestQbit format"); break; } } while (type != EOF); fclose(f); return 0; } int seek_match( char *id, int type ) { if ( !isascii(id[0]) ) return type; switch ( tolower(id[0]) ) { case 's': if (!strcasecmp (id, "SolicitPbit")) return CLI_SOLICIT_PBIT; if (!strcasecmp (id, "SolicitPbit")) return CLI_SOLICIT_PBIT; case 'r': if (!strcasecmp (id, "RequestLife")) return CLI_REQUEST_LIFE; if (!strcasecmp (id, "RequestQbit")) return CLI_REQUEST_QBIT; } return type; } dhcpv6-1.0/compat.h010060000015740003721000000000240625233634200144210ustar00yunzhouip00000400000004#include "netbsd.h" dhcpv6-1.0/dh6.c010060000015740003721000000145300625233634200136210ustar00yunzhouip00000400000004/* * dh6.c Routines for DHCPv6 data structures * * Version: @(#)dh6.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "dh6.h" /* Solicit message length excluding extensions */ inline int dh6_solicit_msg_len(struct dh6_solicit *msg) { return sizeof(struct dh6_solicit) + (msg->Abit+msg->Lbit)*IPV6_ADDR_LEN; } /* Link-local address if present */ inline struct in6_addr * get_solicit_llocal_addr( struct dh6_solicit *msg ) { if ( msg->Lbit ) return( msg->addr ); else return NULL; } /* set Link-local address */ inline void set_solicit_llocal_addr( struct dh6_solicit *msg, struct in6_addr *lladdr ) { if ( !msg->Lbit ) return; memcpy(msg->addr, lladdr, IPV6_ADDR_LEN); } /* relay agent address if present */ inline struct in6_addr * get_solicit_relay_addr( struct dh6_solicit *msg ) { if ( msg->Abit ) return( msg->addr + msg->Lbit ); else return NULL; } /* relay agent address if present */ inline void set_solicit_relay_addr( struct dh6_solicit *msg, struct in6_addr *agent ) { if ( !msg->Abit ) return; memcpy(msg->addr+msg->Lbit, agent, IPV6_ADDR_LEN); } /* extensions */ inline u_int8_t * solicit_ext( struct dh6_solicit *msg ) { return( (u_int8_t *) (msg->addr + msg->Lbit + msg->Abit) ); } /* Advertise message length excluding extensions */ inline int dh6_advertise_msg_len(struct dh6_advertise *msg) { return sizeof(struct dh6_advertise) + (msg->Lbit + msg->SvrCnt)*IPV6_ADDR_LEN; } /* Link-local address if present */ inline struct in6_addr * get_advertise_llocal_addr( struct dh6_advertise *msg ) { if ( msg->Lbit ) return( msg->addr ); else return NULL; } /* set Link-local address */ inline void set_advertise_llocal_addr( struct dh6_advertise *msg, struct in6_addr *lladdr) { if ( !msg->Lbit ) return; memcpy(msg->addr, lladdr, IPV6_ADDR_LEN); } /* a number of server addresses */ inline struct in6_addr * get_advertise_server_addr( struct dh6_advertise *msg ) { if (msg->SvrCnt > 0) return( msg->addr + msg->Lbit ); else return NULL; } /* a number of server addresses */ inline void set_advertise_server_addr( struct dh6_advertise *msg, struct in6_addr *svr_addr, int svr_cnt) { int i; if (msg->SvrCnt == 0) return; for (i=0; iaddr+msg->Lbit+i, svr_addr+i, IPV6_ADDR_LEN); } /* extensions */ inline u_int8_t * advertise_ext( struct dh6_advertise *msg ) { return( (u_int8_t *) (msg->addr + msg->Lbit + msg->SvrCnt) ); } /* Request message length excluding extensions */ inline int dh6_request_msg_len(struct dh6_request *msg) { return sizeof(struct dh6_request) + (msg->Sbit+2)*IPV6_ADDR_LEN; } /* server address if present */ inline struct in6_addr * get_request_server_addr( struct dh6_request *msg ) { if ( msg->Sbit ) return( msg->addr ); else return NULL; } /* server address if present */ inline void set_request_server_addr( struct dh6_request *msg, struct in6_addr *server ) { if ( !msg->Sbit ) return; memcpy(msg->addr, server, IPV6_ADDR_LEN); } /* agent address */ inline struct in6_addr * get_request_agent_addr( struct dh6_request *msg ) { return( msg->addr + msg->Sbit ); } /* agent address */ inline void set_request_agent_addr( struct dh6_request *msg, struct in6_addr *agent ) { memcpy(msg->addr+msg->Sbit, agent, IPV6_ADDR_LEN); } /* Link-local address */ inline struct in6_addr * get_request_llocal_addr( struct dh6_request *msg ) { return( msg->addr + msg->Sbit + 1 ); } /* Link-local address */ inline void set_request_llocal_addr( struct dh6_request *msg, struct in6_addr *lladdr ) { memcpy(msg->addr+msg->Sbit+1, lladdr, IPV6_ADDR_LEN); } /* extensions */ inline u_int8_t * request_ext( struct dh6_request *msg ) { return( (u_int8_t *) (msg->addr + msg->Sbit + 2) ); } /* Reply message length excluding extensions */ inline int dh6_reply_msg_len(struct dh6_reply *msg) { return sizeof(struct dh6_reply) + msg->Lbit*IPV6_ADDR_LEN; } /* Link-local address */ inline struct in6_addr * get_reply_llocal_addr( struct dh6_reply *msg ) { if ( msg->Lbit ) return( msg->addr ); else return NULL; } /* Link-local address */ inline void set_reply_llocal_addr( struct dh6_reply *msg, struct in6_addr *lladdr ) { if ( !msg->Lbit ) return; memcpy(msg->addr, lladdr, IPV6_ADDR_LEN); } /* extensions */ inline u_int8_t * reply_ext( struct dh6_reply *msg ) { return( (u_int8_t *) (msg->addr + msg->Lbit) ); } /* Release message length excluding extensions */ inline int dh6_release_msg_len(struct dh6_release *msg) { return sizeof(struct dh6_release); } /* Reconfigure message length excluding extensions */ inline int dh6_reconfigure_msg_len(struct dh6_reconfigure *msg) { return sizeof(struct dh6_reconfigure); } static struct in6_addr __dh6sin_agent_group, __dh6sin_server_group, __dh6sin_relay_group; static inline void init_dh6_agent_group( void ) { inet_pton(AF_INET6, DH6_AGENT_GROUP, &__dh6sin_agent_group); } inline struct in6_addr * dh6sin_agent_group( void ) { static int flag = 0; if ( !flag ) { init_dh6_agent_group(); flag = 1; } return &__dh6sin_agent_group; } static inline void init_dh6_server_group( void ) { inet_pton(AF_INET6, DH6_SERVER_GROUP, &__dh6sin_server_group); } inline struct in6_addr * dh6sin_server_group( void ) { static int flag = 0; if ( !flag ) { init_dh6_server_group(); flag = 1; } return &__dh6sin_server_group; } static inline struct in6_addr * init_dh6_relay_group( void ) { inet_pton(AF_INET6, DH6_RELAY_GROUP, &__dh6sin_relay_group); } inline struct in6_addr * dh6sin_relay_group( void ) { static int flag = 0; if ( !flag ) { init_dh6_relay_group(); flag = 1; } return &__dh6sin_relay_group; } dhcpv6-1.0/dh6.h010060000015740003721000000163760625233634200136400ustar00yunzhouip00000400000004/* * dh6.h DHCPv6 Data Structures * * Version: @(#)dh6.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __DH6_H #define __DH6_H #define DH6_CLIENT_PORT 546 /* DHCPv6 Client UDP port */ #define DH6_AGENT_PORT 547 /* DHCPv6 Server/Relay UDP port */ #define DH6_AGENT_GROUP "FF02::1:2" /* DHCPv6 Agent multicast group */ #define DH6_SERVER_GROUP "FF05::1:3" /* DHCPv6 Server multicast group */ #define DH6_RELAY_GROUP "FF05::1:4" /* DHCPv6 Relay multicast group */ #ifdef DH6_RELEASE #define DH6_LIFETIME_UNIT 3600 #define DH6_DEFAULT_PREFER_TIME 24 #define DH6_MAX_PREFER_TIME 240 #define DH6_DEFAULT_VALID_TIME 36 #define DH6_MAX_VALID_TIME 360 #else #define DH6_LIFETIME_UNIT 60 #define DH6_DEFAULT_PREFER_TIME 1 #define DH6_MAX_PREFER_TIME 10 #define DH6_DEFAULT_VALID_TIME 2 #define DH6_MAX_VALID_TIME 20 #endif extern struct in6_addr * dh6sin_agent_group( void ); extern struct in6_addr * dh6sin_server_group( void ); extern struct in6_addr * dh6sin_relay_group( void ); /* * Retransmission and configuration parameters */ #define REPLY_MSG_INITIAL_TIMEOUT 2 #define REPLY_MSG_MIN_RETRANS 10 #define REPLY_MSG_RETRANS_INTERVAL 2 #define RECONF_MSG_INITIAL_TIMEOUT 2 #define RECONF_MSG_MIN_RETRANS 10 #define RECONF_MSG_RETRANS_INTERVAL 2 #define RECONF_MSG_MIN_RESP 2 #define RECONF_MSG_MAX_RESP 10 #define RELAY_DISCOVERY_PERIOD 3600 #define MAX_SOLICIT_DELAY 5 #define MAX_ADV_WAIT 5 #define MAX_SOLICIT_RETRANS 10 #define XID_TIMEOUT 10800 #define IPV6_ADDR_LEN 16 /* * DHCP Solicit message * It is safe to allocate a 9x4-byte of buffer for the message */ struct dh6_solicit { #define DH6_SOLICIT 1 u_int8_t type; /* message type */ u_int8_t rsvd1:4, Pbit:1, /* P for Previously cached server */ Abit:1, /* A for relay Agent's address */ Lbit:1, /* L for Link-local address */ Cbit:1; /* C for dellocating resources */ u_int16_t rsvd2; struct in6_addr addr[0]; }; /* Solicit message length excluding extensions */ extern int dh6_solicit_msg_len(struct dh6_solicit *); /* Link-local address if present */ extern struct in6_addr * get_solicit_llocal_addr(struct dh6_solicit *); /* set Link-local address */ extern void set_solicit_llocal_addr(struct dh6_solicit *, struct in6_addr *); /* relay agent address if present */ extern struct in6_addr * get_solicit_relay_addr(struct dh6_solicit *); /* set relay agent address if present */ extern void set_solicit_relay_addr(struct dh6_solicit *, struct in6_addr *); /* extensions */ extern u_int8_t * solicit_ext( struct dh6_solicit * ); /* * DHCP Advertise message */ struct dh6_advertise { #define DH6_ADVERTISE 2 u_int8_t type; /* message type */ u_int8_t rsvd:6, Lbit:1, /* L for Link-local address */ Sbit:1; /* S for Server addresses */ u_int8_t SvrCnt; /* server count */ #define DH6_SVR_TIMEUNIT 4096 #define DH6_NOLIFETIME 0 u_int8_t lifetime; /* lifetime, in units of 4096 seconds */ struct in6_addr AgtAddr; /* agent address */ struct in6_addr addr[0]; }; /* Advertise message length excluding extensions */ extern int dh6_advertise_msg_len(struct dh6_advertise *); /* Link-local address if present */ extern struct in6_addr * get_advertise_llocal_addr(struct dh6_advertise *); /* set Link-local address */ extern void set_advertise_llocal_addr(struct dh6_advertise *, struct in6_addr *); /* a number of server addresses */ extern struct in6_addr * get_advertise_server_addr(struct dh6_advertise *); /* set a number of server addresses */ extern void set_advertise_server_addr(struct dh6_advertise *, struct in6_addr *,int); /* extensions */ extern u_int8_t * advertise_ext(struct dh6_advertise *); /* * DHCP Request message */ struct dh6_request { #define DH6_REQUEST 3 u_int8_t type; /* message type */ u_int8_t rsvd:6, Cbit:1, /* C for Cleaning up resources */ Sbit:1; /* S for Server addresses */ u_int16_t id; /* transaction ID */ struct in6_addr addr[0]; }; /* Request message length excluding extensions */ extern int dh6_request_msg_len(struct dh6_request *); /* server address if present */ extern struct in6_addr * get_request_server_addr(struct dh6_request *); /* set server address if present */ extern void set_request_server_addr(struct dh6_request *, struct in6_addr *); /* agent address */ extern struct in6_addr * get_request_agent_addr(struct dh6_request *); /* set agent address */ extern void set_request_agent_addr(struct dh6_request *, struct in6_addr *); /* Link-local address */ extern struct in6_addr * get_request_llocal_addr(struct dh6_request *); /* set Link-local address */ extern void set_request_llocal_addr(struct dh6_request *, struct in6_addr *); /* extensions */ extern u_int8_t * request_ext(struct dh6_request *); /* * DHCP Reply message */ struct dh6_reply { #define DH6_REPLY 4 u_int8_t type; /* message type */ u_int8_t code:7, /* error code */ Lbit:1; /* L for Link-local address */ u_int16_t id; /* transaction ID */ struct in6_addr addr[0]; }; /* Reply message length excluding extensions */ extern int dh6_reply_msg_len(struct dh6_reply *); /* get Link-local address */ extern struct in6_addr * get_reply_llocal_addr(struct dh6_reply *); /* set Link-local address */ extern void set_reply_llocal_addr(struct dh6_reply *, struct in6_addr *); /* extensions */ extern u_int8_t * reply_ext(struct dh6_reply *); #define DH6_REPLY_SUCCESS 0 #define DH6_REPLY_FAIL_UNKNOWN 16 #define DH6_REPLY_AUTH_FAIL 17 #define DH6_REPLY_POOR_FORM 18 #define DH6_REPLY_RSRC_UNAVAIL 19 #define DH6_REPLY_CLI_REC_UNAVAIL 20 #define DH6_REPLY_INVAL_REL_SRC 21 #define DH6_REPLY_UNABLE_EXT_PARA 22 #define DH6_REPLY_BAD_HAIR_DAY 24 #define DH6_REPLY_INSUFF_FUND 32 #define DH6_REPLY_SVR_UNREACH 64 /* * DHCP Release message */ struct dh6_release { #define DH6_RELEASE 5 u_int8_t type; /* message type */ u_int8_t flags:7, /* message flags: 0 */ Dbit:1; /* D for Directly to the client */ u_int16_t id; /* transaction ID */ struct in6_addr AgtAddr; /* agent address */ struct in6_addr lladdr; /* Link-local address */ u_int8_t ext[0]; /* extensions */ }; /* Release message length excluding extensions */ extern int dh6_release_msg_len(struct dh6_release *); /* * DHCP Reconfigure message */ struct dh6_reconfigure { #define DH6_RECONFIGURE 6 u_int8_t type; /* message type */ u_int8_t flags; /* message flags: 0 */ u_int16_t rsvd; u_int8_t ext[0]; /* extensions */ }; /* Reconfigure message length excluding extensions */ extern int dh6_reconfigure_msg_len(struct dh6_reconfigure *); #endif /* __DH6_H */ dhcpv6-1.0/dh6_adm.h010060000015740003721000000052030625233634200144440ustar00yunzhouip00000400000004/* * dh6_adm.h DHCPv6 Administration Command Formats * * Version: @(#)dh6_adm.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __DH6_ADM_H #define __DH6_ADM_H /* * The UNIX server names for each interface of a DHCPv6 client are: * * dh6cli-icmp. * dh6cli-adm. * * Below is the server path. Every socket will be referenced by * the server path and a server name. */ #define DH6_SERV_PATH "/usr/local/etc/dhcpv6/" #define DH6_TMP "/tmp/dhcpv6.XXXXXX" /* * message */ typedef union dh6_message { struct { u_int8_t type; } msg; struct dh6_solicit sol; struct dh6_advertise adv; struct dh6_request req; struct dh6_reply rpl; struct dh6_release rel; struct dh6_reconfigure conf; } DH6_MESSAGE; #define MAX_MSG_LEN 256 /* ???? */ /* * administration command format */ typedef struct { u_int8_t cmd; u_int8_t bit7, bit6, bit5, bit4, bit3, bit2, bit1, bit0; u_int16_t len; union { u_int8_t data[0]; struct { u_int16_t lport; u_int16_t fport; struct in6_addr laddr; struct in6_addr faddr; DH6_MESSAGE msg; } dh6; #define ADM_DH6MSG_HDRLEN (4 + 2*sizeof(struct in6_addr)) struct { struct in6_addr lladdr; struct in6_addr agent; struct in6_addr client; } sdb; #define ADM_SVRDB_LEN (3*sizeof(struct in6_addr)) struct { struct in6_addr server; struct in6_addr agent; struct in6_addr client; } cdb; #define ADM_CLIDB_LEN (3*sizeof(struct in6_addr)) } un; } ADM_MESSAGE; /* * Administration command value */ #define ADM_CMD_START 0 #define ADM_CMD_RESTART 1 #define ADM_CMD_STOP 2 #define ADM_OPEN_DHCPV6 8 #define ADM_CLOSE_DHCPV6 9 #define ADM_DH6_MSG 16 #define ADM_SHOW_DB 17 extern int debug; #endif /* __DH6_ADM_H */ dhcpv6-1.0/dh6_cli.c010060000015740003721000001227120625233634200144520ustar00yunzhouip00000400000004/* * dh6_cli.c DHCPv6 Client Daemon * * Version: @(#)dh6_cli.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_if.h" #include "dh6_cli.h" #include "dh6_adm.h" #include "dh6_db.h" extern void cli_run_unix_server( void * ); extern void cli_adm_msgrcv( void * ); extern void cli_dh6_msg_rcv( void * ); static void cli_dh6_multicast_rcv( void * ); extern void cia_more_reply_timeout( void * ); extern void cia_release_timeout( void * ); extern void cia_prefer_life_timeout( void * ); extern void cia_valid_life_timeout( void * ); extern void cli_solicit_timeout( void * ); extern void cia_request_timeout( void * ); extern int cli_multicast_solicit(char *, ...); extern int cli_request_send( struct cli_ifaddr *, char *, ...); extern UNION_LIST ifi_table; UNION_LIST server_list, relay_list, client_list; /* link local address not on this list */ struct u_timer solicit_timer; /* Solicit retransmission timer */ u_int8_t solicit_rc; /* Solicit retransmission counter */ u_int8_t send_request_wait = 0; IF_INFO *this_ifi; /* the current interface */ struct fd_list multi_sock; /* multicast socket */ struct fd_list ll_sock; /* socket for the link local address */ struct in6_addr *lladdr; /* link local address */ extern int quit_flag; extern int debug; int SolicitPbit = 1; int SolicitCbit = 1; int RequestLife = DH6_DEFAULT_PREFER_TIME; int RequestQbit = 0; /* * DHCPv6 client main module, called when * 1. Router Advertisement comes up with M flag set; OR * 2. no router is available after reasonable time; OR * 3. in required to adminsitration. * * There is one UDP socket for the link-local address or each * DHCPv6 address. The link-local socket should be always opened. * After the client acquires an intended DHCPv6 address, * the socket should be opened accordingly. */ int dh6_client_main( int ifindex ) { struct fd_list ufd; struct poll_list upl; struct cli_ifaddr *cia; int optval; u_free_list_init(); reset_timer_table(); reset_fd_list(); reset_poll_list(); begin_timing(); init_ifi_table(); get_ifi_table(); dh6_client_init(); if ( cli_check_ifi_valid(ifindex) < 0 ) { log_warn(1101, "interface invalid"); exit(1); } /* * build up interface extension; * build up Link-local address extension; * and etc; */ /* * reboot from previous cache; * restore all the lists; * and etc. */ read_dh6_client_conf(); /* read from "dh6_client.conf" */ read_dh6_client_boot(); /* read from "dh6_client.boot" */ /* open unix socket; listen for incoming administration commands. */ if ( (ufd.fd = open_unix_sock( dh6cli_adm_server_name(ifi_ifname(this_ifi)))) < 0 ) log_fatal(1102, "open unix socket fail"); init_poll(&upl); upl.data = &ufd; upl.function = cli_run_unix_server; add_poll(&upl); if ( (multi_sock.fd=cli_udp6_socket(NULL)) < 0) log_fatal(1103, "open UDP6 socket fail"); #ifdef IPV6_TXINFO_WORK optval = 1; if (setsockopt(multi_sock.fd, IPPROTO_IPV6, IPV6_TXINFO, (char *)&optval, sizeof(optval)) < 0) log_fatal(1104, "IPV6_TXINFO fail"); #endif optval = 1; if (setsockopt(multi_sock.fd, IPPROTO_IPV6, IPV6_RXINFO, (char *)&optval, sizeof(optval)) < 0) log_fatal(1105, "IPV6_RXINFO fail"); init_fdp(&multi_sock); multi_sock.data = &multi_sock; multi_sock.function = cli_dh6_multicast_rcv; add_fdp(&multi_sock); #ifdef DH6_DEBUG if ( look_xmit_more() ) log_info("bind to link local address %s", inet_ntop(AF_INET6, lladdr, 16, NULL)); #endif /* open the link-local socket */ if ( (ll_sock.fd=cli_udp6_socket(lladdr)) < 0 ) log_fatal(1103, "open UDP6 socket fail"); if (setsockopt(ll_sock.fd, IPPROTO_IPV6, IP_MULTICAST_IF, (char *)lladdr, IPV6_ADDR_LEN) < 0) log_fatal(1104, "IP_MULTICAST_IF fail"); /* * TODO: we should do something here to set the * hop limit to 1. */ init_fdp(&ll_sock); ll_sock.data = NULL; ll_sock.function = cli_dh6_msg_rcv; add_fdp(&ll_sock); /* open all the sockets for DHCPv6 address */ for ( cia = client_list.cia_head; cia != NULL; cia = cia->next ) { if ( cia_addr_verified(cia) ) { if ((cia->cia_sk.fd=cli_udp6_socket(&cia->cia_addr)) < 0) log_fatal(1105, "open UDP6 socket fail"); if (setsockopt(cia->cia_sk.fd, IPPROTO_IPV6, IP_MULTICAST_IF, (char *)&cia->cia_addr, IPV6_ADDR_LEN) < 0) log_fatal(1106, "IP_MULTICAST_IF fail"); init_fdp(&cia->cia_sk); cia->cia_sk.data = cia; cia->cia_sk.function = cli_dh6_msg_rcv; add_fdp(&cia->cia_sk); } } init_timer(&solicit_timer); solicit_timer.data = (void *)NULL; solicit_timer.function = cli_solicit_timeout; /* * if there is no server on list, start relay/server discovery * procedure using the link-local socket. Otherwise, * initiate Request/Reply transaction. */ if ( server_list.cs_head == NULL ) { cli_multicast_solicit("PC", SolicitPbit, SolicitCbit); /* * TODO: a random delay between 0 and MAX_SOLICIT_DELAY * see more in section 5.1, draft 08 */ start_timer(&solicit_timer, MAX_ADV_WAIT*SECONDS); solicit_rc = 1; send_request_wait = 1; } else { cia = client_list.cia_head; if ( cia == NULL ) cli_start_request_proc(NULL, NULL, NULL, 0, 0, NULL); else { for ( ; cia != NULL; cia = cia->next ) cli_start_request_proc(cia, NULL, NULL, 1, 0, NULL); } send_request_wait = 0; } quit_flag = 0; for (;;) { dispatch(); if ( quit_flag ) break; } end_timing(); del_poll(&upl); for ( cia = client_list.cia_head; cia != NULL; cia = cia->next ) { if ( cia->cia_sk.fd >= 0 ) { del_fdp( &cia->cia_sk ); close( cia->cia_sk.fd ); } } del_fdp( &ll_sock ); close( ll_sock.fd ); del_fdp(&multi_sock); close(multi_sock.fd); close_unix_sock( ufd.fd, dh6cli_adm_server_name(ifi_ifname(this_ifi)) ); closelog(); exit(0); } inline struct cli_relay * cr_create( void ) { struct cli_relay *cr; if ( (cr=u_alloc_node()) == NULL ) return NULL; cr->cr_issvr = NULL; return cr; } inline void cr_destroy( struct cli_relay *cr ) { if ( cr->cr_issvr ) { cr->cr_issvr->cs_rly = NULL; /* the server entry should be released separately */ } u_free_node(cr); } inline struct cli_relay * cr_get( struct in6_addr *addr ) { struct cli_relay *cr; for (cr = relay_list.cr_head; cr != NULL; cr = cr->next) { if ( !memcmp(&cr->cr_addr, addr, IPV6_ADDR_LEN) ) return cr; } return NULL; } inline struct cli_server * cs_create( void ) { struct cli_server *cs; if ( (cs=u_alloc_node()) == NULL ) return NULL; cs->cs_rly = NULL; return cs; } inline void cs_destroy( struct cli_server *cs ) { u_free_node(cs); } inline struct cli_server * cs_get( struct in6_addr *addr ) { struct cli_server *cs; for (cs = server_list.cs_head; cs != NULL; cs = cs->next) { if ( !memcmp(&cs->cs_addr, addr, IPV6_ADDR_LEN) ) return cs; } return NULL; } struct cli_ifaddr * cia_create( void ) { struct cli_ifaddr *cia; if ( (cia=u_alloc_node()) == NULL ) return NULL; cia->cia_ifi = NULL; cia->cia_svr = NULL; cia->cia_rly = NULL; init_timer(&cia->cia_xmit_timer); cia->cia_xmit_timer.data = (void *)cia; cia->cia_xmit_timer.function = (void (*)(void *))cia_request_timeout; cia->cia_xmit_rc = 0; init_timer(&cia->cia_life_timer); cia->cia_life_timer.data = (void *)cia; cia->cia_life_timer.function = u_ignore; cia->cia_state = CIA_MSG_NONE | CIA_ADDR_NONE; cia->cia_sk.fd = 0; cia->cia_extlen = 0; cia->cia_ext = NULL; return cia; } inline void cia_destroy( struct cli_ifaddr *cia ) { close( cia->cia_sk.fd ); stop_timer(&cia->cia_xmit_timer); stop_timer(&cia->cia_life_timer); if ( cia->cia_ext ) free(cia->cia_ext); u_free_node(cia); } inline struct cli_ifaddr * cia_get( struct in6_addr *addr ) { struct cli_ifaddr *cia; for (cia = client_list.cia_head; cia != NULL; cia = cia->next) { if ( !memcmp(&cia->cia_addr, addr, IPV6_ADDR_LEN) ) return cia; } return NULL; } inline struct cli_ifaddr * cia_get_by_server_id( struct in6_addr *server, int id ) { struct cli_ifaddr *cia; for (cia = client_list.cia_head; cia != NULL; cia = cia->next) { if ( !memcmp(&cia->cia_svr->cs_addr, server, IPV6_ADDR_LEN) && cia->cia_id == id ) return cia; } return NULL; } inline struct cli_ifaddr * cia_get_by_relay_id( struct in6_addr *relay, int id ) { struct cli_ifaddr *cia; for (cia = client_list.cia_head; cia != NULL; cia = cia->next) { if ( !memcmp(&cia->cia_rly->cr_addr, relay, IPV6_ADDR_LEN) && cia->cia_id == id ) return cia; } return NULL; } inline struct cli_ifaddr * cia_get_by_server_relay( struct in6_addr *server, struct in6_addr *relay ) { struct cli_ifaddr *cia; for (cia = client_list.cia_head; cia != NULL; cia = cia->next) { if ( !memcmp(&cia->cia_svr->cs_addr, server, IPV6_ADDR_LEN) && !memcmp(&cia->cia_rly->cr_addr, relay, IPV6_ADDR_LEN) ) return cia; } return NULL; } static int cia_next_trans_id = 0; static inline int cia_get_next_trans_id( void ) { return cia_next_trans_id++; } int dh6_client_init( void ) { server_list.chain.head = NULL; server_list.chain.tail = NULL; relay_list.chain.head = NULL; relay_list.chain.tail = NULL; client_list.chain.head = NULL; client_list.chain.tail = NULL; } /* * Validation of interface and DHCPv6 address * To be completed ... */ int cli_check_ifi_valid( int ifindex ) { this_ifi = seek_ifi_byindex(ifindex); if (this_ifi == NULL) return -1; lladdr = ifi_lladdr(this_ifi); return 1; } /* * to receive DHCPv6 multicast messages */ void cli_dh6_multicast_rcv( void * data ) { struct fd_list *sock = (struct fd_list *)data; u_int8_t buf[MAX_MSG_LEN]; u_int8_t ctrldata[64]; for (;;) { struct iovec aiov[1]; struct msghdr msg; struct cmsghdr *cmsg = (struct cmsghdr *)ctrldata; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)buf; struct sockaddr_in6 sin6; int len; msg.msg_name = (caddr_t)&sin6; msg.msg_namelen = sizeof(struct sockaddr_in6) ; msg.msg_iov = aiov; msg.msg_iovlen = 1; aiov[0].iov_base = buf; aiov[0].iov_len = MAX_MSG_LEN; msg.msg_control = ctrldata; msg.msg_controllen = sizeof(ctrldata); msg.msg_flags = 0; len = recvmsg(sock->fd, &msg, 0); /* * It is very possible for signal SIGCHLD to interrupt this * slow system call recvfrom */ __ugly0: if (len == 0) return; else if (len < 0) { if (errno == EINTR) goto __ugly0; if (errno == EWOULDBLOCK) return; /* no more messages */ log_sys(1114, "recvfrom"); } switch ( dh6msg->msg.type ) { case DH6_RECONFIGURE: cli_reconfigure_rcv(NULL, &msg, len); break; default: log_warn(3015,"unknown message %u", dh6msg->msg.type); } } return; } /* * to receive DHCPv6 messages */ void cli_dh6_msg_rcv( void * data ) { struct cli_ifaddr *cia = (struct cli_ifaddr *)data; int fd = (cia) ? cia->cia_sk.fd : ll_sock.fd; u_int8_t buf[MAX_MSG_LEN]; u_int8_t ctrldata[64]; for (;;) { struct iovec aiov[1]; struct msghdr msg; struct cmsghdr *cmsg = (struct cmsghdr *)ctrldata; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)buf; struct sockaddr_in6 sin6; int len; msg.msg_name = (caddr_t)&sin6; msg.msg_namelen = sizeof(struct sockaddr_in6) ; msg.msg_iov = aiov; msg.msg_iovlen = 1; aiov[0].iov_base = buf; aiov[0].iov_len = MAX_MSG_LEN; msg.msg_control = ctrldata; msg.msg_controllen = sizeof(ctrldata); msg.msg_flags = 0; len = recvmsg(fd, &msg, 0); /* * It is very possible for signal SIGCHLD to interrupt this * slow system call recvfrom */ __ugly: if (len == 0) return; else if (len < 0) { if (errno == EINTR) goto __ugly; if (errno == EWOULDBLOCK) return; /* no more messages */ log_sys(1107, "recvmsg"); } switch ( dh6msg->msg.type ) { case DH6_ADVERTISE: cli_advertise_rcv(cia, &msg, len); break; case DH6_REPLY: cli_reply_rcv(cia, &msg, len); break; case DH6_RECONFIGURE: cli_reconfigure_rcv(cia, &msg, len); break; default: log_warn(1108,"unknown message %u", dh6msg->msg.type); } } return; } /* * On receiving DHC Advertise message */ int cli_advertise_rcv(struct cli_ifaddr *cia, struct msghdr *msg, int len) { struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; struct cli_relay *cr; struct cli_server *cs; struct in6_addr *addr; int i; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving Advertise message from %s", inet_ntop(AF_INET6, &sin6->sin6_addr, 16, NULL)); #endif if (dh6msg->adv.SvrCnt == 0 && dh6msg->adv.Sbit == 0) { log_warn(1109, "SvrCnt==0 but Sbit==0"); return -1; } if (dh6msg->adv.Sbit && IN6_IS_MULTICAST(&dh6msg->adv.AgtAddr) ) { log_warn(1110, "Found multicast server address"); return -1; } addr = get_advertise_server_addr(&dh6msg->adv); for (i=0; iadv.SvrCnt; i++) { if ( IN6_IS_MULTICAST(addr) ) { log_warn(1111, "Found multicast server address"); return -1; } addr++; } if ( !(cr=cr_get(&dh6msg->adv.AgtAddr)) ) { if ( (cr=cr_create()) == NULL ) return -1; memcpy(&cr->cr_addr, &dh6msg->adv.AgtAddr, IPV6_ADDR_LEN); u_queue_head(&relay_list, cr); if ( dh6msg->adv.Sbit ) { /* also server address */ if ( (cs=cs_create()) == NULL ) return -1; memcpy(&cs->cs_addr, &dh6msg->adv.AgtAddr, IPV6_ADDR_LEN); cs->cs_rly = cr; u_queue_head(&server_list, cs); cr->cr_issvr = cs; } } addr = get_advertise_server_addr(&dh6msg->adv); for (i=0; iadv.SvrCnt; i++) { if ( !(cs=cs_get(addr)) ) { if ( (cs=cs_create()) == NULL ) return -1; memcpy(&cs->cs_addr, addr, IPV6_ADDR_LEN); u_queue_head(&server_list, cs); } cs->cs_rly = cr; addr++; } stop_timer(&solicit_timer); if ( send_request_wait ) { struct cli_ifaddr *cia2; if ( client_list.cia_head == NULL ) cli_start_request_proc(NULL, NULL, NULL, 0, 0, NULL); else { for (cia2 = client_list.cia_head; cia2 != NULL; cia2 = cia2->next ) cli_start_request_proc(cia2, NULL, NULL, 1, 0, NULL); } send_request_wait = 0; } /* * TODO: Am I interested in extensions if any? */ return 0; } /* * On receiving DHC Reply message */ int cli_reply_rcv(struct cli_ifaddr *cia, struct msghdr *msg, int len) { struct cli_ifaddr *cia2 = NULL; struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; struct ext6_addr *addrext; struct ext6_multicast *mcastext; DB *db; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving Reply message from %s", inet_ntop(AF_INET6, &sin6->sin6_addr, 16, NULL)); #endif if (dh6msg->rpl.Lbit && (cia2=cia_get_by_relay_id(&sin6->sin6_addr,ntohs(dh6msg->rpl.id))) == NULL ) { log_warn(1112, "Reply not forwarded by relay"); return -1; } if (!dh6msg->rpl.Lbit && (cia2=cia_get_by_server_id(&sin6->sin6_addr,ntohs(dh6msg->rpl.id))) == NULL ) { log_warn(1113, "Reply not sent by server directly"); return -1; } addrext = (struct ext6_addr *)ext6_get(EXT6_ADDR, reply_ext(&dh6msg->rpl), len - dh6_reply_msg_len(&dh6msg->rpl)); mcastext = (struct ext6_multicast *)ext6_get(EXT6_MULTICAST, reply_ext(&dh6msg->rpl), len - dh6_reply_msg_len(&dh6msg->rpl)); if (addrext == NULL) { log_warn(1115, "No address extension in Reply message"); return -1; } if ( !addrext->Cbit ) { log_warn(1116, "No client address found in Reply extension"); return -1; } #ifdef TODO /* to check if it provides the correct authetication info. */ if ( fail_authen_info(&dh6msg->rpl) ) { cli_request_send(cia, ""); start_timer(&cia->cia_xmit_timer, REPLY_MSG_RETRANS_INTERVAL); cia->cia_xmit_rc++; log_warn("fail in providing the correct authetication info."); return -1; } #endif /* in respond to Release message */ if ( cia2->cia_state & CIA_REL_WAIT ) { #ifdef TODO void *ext2 = NULL; int len2 = 0; for (;;) { ext2 = server_not_released(&dh6msg->rpl,&len2); if (ext2 == NULL || len2 == 0) break; log_info("server not release error %d", dh6msg->rpl.code); } for (;;) { ext2 = server_released(&dh6msg->rpl,&len2); if (ext2 == NULL || len2 == 0) break; release_particular_parameters(cia,msg); cli_purge_boot(cia, msg); } if ( some_extensions_pending(cia,msg) ) return 0; /* to wait for more */ #endif stop_timer(&cia2->cia_xmit_timer); cia2->cia_state |= CIA_REL_CLRD; #ifdef TODO if ( all_parameters_released(cia,msg) ) { #endif dh6_remove_addr6(ifi_ifname(this_ifi), strlen(ifi_ifname(this_ifi)), &cia2->cia_addr); if ( (db=dh6db_open(DH6CLI_BOOT)) < 0) log_sys(1117, "dbopen"); if (dh6db_locate(db, cia2) == 0) { dh6db_del(db, cia2, R_CURSOR); dh6db_sync(db); } dh6db_close(db); u_unlink(&client_list, cia2); cia_destroy(cia2); #ifdef TODO } #endif return 0; } /* in respond to Request message */ if ( cia2->cia_xmit_rc == 0 && /* received the replies for all the retransmissions */ !(cia2->cia_state & CIA_REQ_WAIT || cia2->cia_state & CIA_RPL_MORE) ) { log_warn(1118,"Reply received in an incorrect state"); return -1; } if (dh6msg->rpl.code != DH6_REPLY_SUCCESS) { stop_timer(&cia2->cia_xmit_timer); log_info("Request rejected with code %d", dh6msg->rpl.code); #ifdef TODO if ( some_extension_missing( reply_ext(dh6msg->rpl) ) ) { cia2->cia_xmit_timer.function = (void (*)(void *))cia_more_reply_timeout; start_timer(&cia2->cia_xmit_timer, REPLY_MSG_INITIAL_TIMEOUT); /* to receive more Reply */ return 0; } #endif if ( !(cia2->cia_state & CIA_ADDR_PRFD || cia2->cia_state & CIA_ADDR_VALID) ) { u_unlink(&client_list, cia2); cia_destroy(cia2); } else cia2->cia_state |= CIA_REQ_CLRD; return 0; } cia2->cia_prfsize = addrext->PrfSize; memcpy( &cia2->cia_addr, get_ext6_addr_client_addr(addrext), IPV6_ADDR_LEN ); cia2->cia_prefer_life = get_ext6_addr_prefer_lifetime(addrext); cia2->cia_valid_life = get_ext6_addr_valid_lifetime(addrext); stop_timer(&cia2->cia_xmit_timer); if (cia2->cia_xmit_rc > 0) cia2->cia_xmit_rc -= 1; cia2->cia_req_life -= get_ext6_addr_prefer_lifetime( (struct ext6_addr *)reply_ext(&dh6msg->rpl)); #ifdef DH6_DEBUG if ( look_xmit() ) log_info("Got a DHCPv6 address %s!!!", inet_ntop(AF_INET6, &cia2->cia_addr, 16, NULL)); #endif #ifdef TODO if ( the_first_time_assigned(&cia2->cia_addr) ) dup_addr_detect(&cia2->cia_addr); #endif dh6_assign_addr6(ifi_ifname(this_ifi), strlen(ifi_ifname(this_ifi)), &cia2->cia_addr, cia2->cia_prfsize, 0); if ( (db=dh6db_open(DH6CLI_BOOT)) < 0) log_sys(1119, "dbopen"); dh6db_put(db, cia2, R_NOOVERWRITE); dh6db_sync(db); dh6db_close(db); cia2->cia_life_timer.function = (void (*)(void *))cia_prefer_life_timeout; start_timer(&cia2->cia_life_timer, cia2->cia_prefer_life*DH6_LIFETIME_UNIT); cia2->cia_state &= CIA_ADDR_PRFD | 0x0f; if ((cia2->cia_sk.fd=cli_udp6_socket(&cia2->cia_addr)) < 0) log_fatal(1120, "open UDP6 socket fail"); if (setsockopt(cia2->cia_sk.fd, IPPROTO_IPV6, IP_MULTICAST_IF, (char *)&cia2->cia_addr, IPV6_ADDR_LEN) < 0) log_fatal(1121, "IP_MULTICAST_IF fail"); init_fdp(&cia2->cia_sk); cia2->cia_sk.data = cia2; cia2->cia_sk.function = cli_dh6_msg_rcv; add_fdp(&cia2->cia_sk); /* join server multicast group */ if (mcastext != NULL) { struct ipv6_mreq mr6; int optval; memcpy(&mr6.ipv6mr_interface, &cia2->cia_addr, IPV6_ADDR_LEN); memcpy(&mr6.ipv6mr_multiaddr, &mcastext->addr, IPV6_ADDR_LEN); if (setsockopt(cia2->cia_sk.fd, IPPROTO_IPV6, IP_ADD_MEMBERSHIP, (caddr_t)&mr6, sizeof(mr6)) < 0) log_fatal(3007, "server IP_ADD_MEMBERSHIP fail"); } #ifdef TODO /* * 1. to handle other extension; * 2. to check if any missing extensions; */ cli_process_other_extensions( reply_ext(dh6msg->rpl) ); if ( some_extension_missing( reply_ext(dh6msg->rpl) ) ) { cia2->cia_xmit_timer.function = (void (*)(void *))cia_more_reply_timeout; start_timer(&cia2->cia_xmit_timer, REPLY_MSG_INITIAL_TIMEOUT); /* to receive more Reply */ return 0; } #endif cia2->cia_state |= CIA_REQ_CLRD; return 0; } /* * On receiving DHC Reconfigure message */ int cli_reconfigure_rcv(struct cli_ifaddr *cia, struct msghdr *msg, int len) { struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; int extlen = 0; void *ext = NULL; struct cli_ifaddr *cia2 = cia; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving Reconfigure message from %s", inet_ntop(AF_INET6, &sin6->sin6_addr, 16, NULL)); #endif if ( cia2 == NULL ) { if ((cia2=client_list.cia_head) == NULL) { log_warn(1116, "no client entry"); return -1; } } if (memcmp(&sin6->sin6_addr, &cia2->cia_svr->cs_addr, IPV6_ADDR_LEN)) { cli_start_request_proc(NULL, NULL, NULL, 0, 0, NULL); return 0; } #ifdef TODO while ( extract_an_extension(&dh6msg->conf) ) { append_matching_extension(&ext, &extlen); } #endif cia2->cia_xmit_rc = 0; cia2->cia_id = cia_get_next_trans_id(); /* * should delay a random amount of time between * RECONF_MSG_MIN_RESP and RECONF_MSG_MAX_RESP */ cli_start_request_proc(cia2, &cia2->cia_svr->cs_addr, &cia2->cia_rly->cr_addr, 1, extlen, ext); return 0; } /* * Start to send DHCP Request message */ int cli_start_request_proc( struct cli_ifaddr *cia, /* client entry */ struct cli_server *cs, /* server entry */ struct cli_relay *cr, /* relay entry */ int Cbit, /* Clean bit */ int extlen, /* length of extension */ void *ext) { struct cli_ifaddr *cia2 = cia; int fd; #ifdef DH6_DEBUG if ( look_xmit_more() ) log_info("cli_start_request_proc(cia=%p,cs=%p,cr=%p,Cbit=%d)", cia, cs, cr, Cbit); #endif if ( cia2 == NULL ) { if ( server_list.cs_head == NULL ) { /* server not available */ log_warn(1123, "server not available"); return -1; } if ( (cia2=cia_create()) == NULL ) return -1; cia2->cia_ifi = this_ifi; u_queue_tail(&client_list, cia2); } cia2->cia_svr = (cs) ? cs : server_list.cs_head; cia2->cia_rly = (cr) ? cr : cia2->cia_svr->cs_rly; cia2->cia_xmit_rc = 0; cia2->cia_id = cia_get_next_trans_id(); fd = ( cia_addr_verified(cia2) ) ? cia2->cia_sk.fd : ll_sock.fd; if (extlen == 0 || ext == NULL) { cia2->cia_extlen = 0; cia2->cia_ext = CLI_APPEND_ADDR_EXT6(cia2->cia_ext, &cia2->cia_extlen, RequestLife, DH6_DEFAULT_VALID_TIME, RequestQbit); } else { cia2->cia_extlen = extlen; cia2->cia_ext = ext; } if ( cia2->cia_rly->cr_issvr ) { cli_request_send(cia2, "SCdf", 0, Cbit, &cia2->cia_svr->cs_addr, fd); } else { cli_request_send(cia2, "SCdf", 1, Cbit, &cia2->cia_rly->cr_addr, fd); } start_timer(&cia2->cia_xmit_timer, REPLY_MSG_RETRANS_INTERVAL); cia2->cia_xmit_rc++; cia2->cia_state |= CIA_REQ_WAIT; return 0; } void cli_run_unix_server( void * data ) { struct fd_list *p = (struct fd_list *)data, *fdp; int fd; struct sockaddr_un unix_addr; int unix_len = sizeof(unix_addr); for (;;) { fd = accept(p->fd, (struct sockaddr *)&unix_addr, &unix_len); if (fd < 0) { if ( errno!=EWOULDBLOCK ) log_sys(1124, "accept"); else return; /* no more pending connections */ } else { if ( (fdp=malloc(sizeof(struct fd_list))) == NULL ) log_sys(1125, "malloc"); init_fdp(fdp); fdp->fd = fd; fdp->data = fdp; fdp->function = cli_adm_msgrcv; add_fdp(fdp); } } } /* * to receive administration commands */ void cli_adm_msgrcv( void * data ) { struct fd_list *p = (struct fd_list *)data; ADM_MESSAGE msg; DH6_MESSAGE *dh6=(DH6_MESSAGE *)(&msg.un.dh6.msg); int len; for (;;) { len = recv(p->fd, (char*)&msg, MAX_MSG_LEN, 0); if ( len==0 ) return; else if (len < 0) { if (errno == EINTR) continue; else log_sys(1126, "recv"); } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving a message from dh6cc"); #endif if (msg.cmd == ADM_CMD_STOP ) { quit_flag = 1; break; } if (msg.cmd == ADM_SHOW_DB ) { cli_dbshow_adm(msg, len); continue; } if (msg.cmd == ADM_DH6_MSG ) { switch ( dh6->msg.type ) { case DH6_REQUEST: cli_request_adm(&msg, len); break; case DH6_RELEASE: cli_release_adm(&msg, len); break; default: log_warn(1128,"unknown message %u", dh6->msg.type); } } } close(p->fd); p->fd=-1; del_fdp(p); free(p); } /* * On receiving a Request message from another process */ int cli_request_adm( ADM_MESSAGE *msg, int len ) { DH6_MESSAGE *dh6=(DH6_MESSAGE *)(&msg->un.dh6.msg); struct cli_ifaddr *cia; struct cli_server *cs = NULL; struct cli_relay *cr = NULL; struct sockaddr_in6 to6; int fd; if ( dh6->req.Sbit ) cs = cs_get(get_request_server_addr(&dh6->req)); else cs = cs_get(&msg->un.dh6.faddr); if (cs == NULL) { log_warn(1129, "server address not on list"); return -1; } cr = cr_get(get_request_agent_addr(&dh6->req)); if (cr == NULL) { log_warn(1129, "relay address not on list"); return -1; } cia = cia_get_by_server_relay(&cs->cs_addr, &cr->cr_addr); if (cia == NULL) { if ( (cia=cia_create()) == NULL ) return -1; cia->cia_ifi = this_ifi; u_queue_tail(&client_list, cia); } cia->cia_svr = cs; cia->cia_rly = cr; cia->cia_id = cia_get_next_trans_id(); cia->cia_extlen = msg->len - dh6_request_msg_len(&dh6->req) - ADM_DH6MSG_HDRLEN; if ( cia->cia_ext ) cia->cia_ext = realloc(cia->cia_ext, cia->cia_extlen); else cia->cia_ext = malloc(cia->cia_extlen); memcpy(cia->cia_ext, request_ext(&dh6->req), cia->cia_extlen); bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, &msg->un.dh6.faddr, sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_AGENT_PORT); dh6->req.id = htons(cia->cia_id); #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Request len:%d, to: %s, port:%d", msg->len-ADM_DH6MSG_HDRLEN, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif fd = ( cia_addr_verified(cia) ) ? cia->cia_sk.fd : ll_sock.fd; _resend_request2: if (sendto(fd, dh6, msg->len-ADM_DH6MSG_HDRLEN, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != msg->len-ADM_DH6MSG_HDRLEN) { if ( errno==EINTR ) goto _resend_request2; if ( errno==EINVAL ) goto _resend_request2; log_sys_warn(1136, "sendto"); } cia->cia_xmit_timer.function = (void (*)(void *))cia_request_timeout; start_timer(&cia->cia_xmit_timer, REPLY_MSG_RETRANS_INTERVAL); cia->cia_xmit_rc = 1; cia->cia_state |= CIA_REQ_WAIT; return 0; } /* * On receiving a Release message from another process */ int cli_release_adm( ADM_MESSAGE *msg, int len ) { DH6_MESSAGE *dh6=(DH6_MESSAGE *)(&msg->un.dh6.msg); struct cli_ifaddr *cia; struct cli_server *cs = NULL; struct cli_relay *cr = NULL; struct sockaddr_in6 to6; int fd; cia = cia_get_by_server_relay(&msg->un.dh6.faddr, &dh6->rel.AgtAddr); if ( cia == NULL ) { log_warn(1129, "The client entry to be released not found"); return -1; } if (msg->len-ADM_DH6MSG_HDRLEN <= dh6_release_msg_len(&dh6->rel)) { /* no extension */ cli_start_request_proc(cia, NULL, NULL, 1, 0, NULL); return 0; } cia->cia_id = cia_get_next_trans_id(); cia->cia_extlen = msg->len - dh6_release_msg_len(&dh6->rel) - ADM_DH6MSG_HDRLEN; if ( cia->cia_ext ) cia->cia_ext = realloc(cia->cia_ext, cia->cia_extlen); else cia->cia_ext = malloc(cia->cia_extlen); memcpy(cia->cia_ext, dh6->rel.ext, cia->cia_extlen); bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, &msg->un.dh6.faddr, sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_AGENT_PORT); dh6->req.id = htons(cia->cia_id); #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Release len:%d, to: %s, port:%d", msg->len-ADM_DH6MSG_HDRLEN, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif fd = ( cia_addr_verified(cia) ) ? cia->cia_sk.fd : ll_sock.fd; _resend_release2: if (sendto(fd, dh6, msg->len-ADM_DH6MSG_HDRLEN, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != msg->len-ADM_DH6MSG_HDRLEN) { if ( errno==EINTR ) goto _resend_release2; if ( errno==EINVAL ) goto _resend_release2; log_sys_warn(1137, "sendto"); } cia->cia_xmit_timer.function = (void (*)(void *))cia_release_timeout; start_timer(&cia->cia_xmit_timer, REPLY_MSG_RETRANS_INTERVAL); cia->cia_xmit_rc = 1; cia->cia_state |= CIA_REL_WAIT; return 0; } /* * Solicit transmission timeout */ void cli_solicit_timeout( void * data ) { if ( solicit_rc <= MAX_SOLICIT_RETRANS ) { cli_multicast_solicit(""); start_timer(&solicit_timer, MAX_ADV_WAIT*SECONDS); solicit_rc++; } else log_warn(1129,"agent not available"); } /* * Request transmission timeout */ void cia_request_timeout( void * data ) { struct cli_ifaddr *cia = (struct cli_ifaddr *)data; if ( cia->cia_xmit_rc <= REPLY_MSG_MIN_RETRANS ) { cli_request_send(cia, ""); start_timer(&cia->cia_xmit_timer, REPLY_MSG_RETRANS_INTERVAL); cia->cia_xmit_rc++; } else { struct cli_server *cs; for (cs = server_list.cs_head; cs != NULL; cs = cs->next) { if (cs != cia->cia_svr) { cia->cia_svr = cs; cia->cia_rly = cs->cs_rly; break; } } if (cs != NULL) { if ( !cs->cs_rly->cr_issvr ) cli_request_send(cia, "Sd", 1, &cia->cia_rly->cr_addr); else cli_request_send(cia, "Sd", 0, &cs->cs_addr); start_timer(&cia->cia_xmit_timer, REPLY_MSG_RETRANS_INTERVAL); cia->cia_xmit_rc = 1; } else log_warn(1130,"server not available"); } } /* * Timeout for receiving more reply */ void cia_more_reply_timeout( void * data ) { struct cli_ifaddr *cia = (struct cli_ifaddr *)data; cia->cia_xmit_timer.function = (void (*)(void *))cia_request_timeout; start_timer(&cia->cia_xmit_timer, REPLY_MSG_RETRANS_INTERVAL); cli_request_send(cia, ""); cia->cia_xmit_rc++; } /* * Timeout for transmitting a Release message */ void cia_release_timeout( void * data ) { struct cli_ifaddr *cia = (struct cli_ifaddr *)data; DB *db; log_warn(1131, "Release not reponded by server"); cia->cia_state |= CIA_REL_CLRD; #ifdef TODO release_desired_parameters(cia); cli_purge_boot(cia); if ( all_parameters_tobe_released(cia) ) { #endif dh6_remove_addr6(ifi_ifname(this_ifi), strlen(ifi_ifname(this_ifi)), &cia->cia_addr); if ( (db=dh6db_open(DH6CLI_BOOT)) < 0) log_sys(1132, "dbopen"); if (dh6db_locate(db, cia) == 0) { dh6db_del(db, cia, R_CURSOR); dh6db_sync(db); } dh6db_close(db); u_unlink(&client_list, cia); cia_destroy(cia); #ifdef TODO } #endif } /* * When the preferred lifetime expires */ void cia_prefer_life_timeout( void * data ) { struct cli_ifaddr *cia = (struct cli_ifaddr *)data; DB *db; if ( cia->cia_req_life > 0 ) { /* to continue to request the same address */ cia->cia_id = cia_get_next_trans_id(); cli_request_send(cia, "SCdf", 0, 0, &cia->cia_svr->cs_addr, cia->cia_sk.fd); cia->cia_xmit_timer.function = (void (*)(void *))cia_request_timeout; start_timer(&cia->cia_xmit_timer, REPLY_MSG_RETRANS_INTERVAL); cia->cia_xmit_rc = 1; cia->cia_state |= CIA_REQ_WAIT; } cia->cia_life_timer.function = (void (*)(void *))cia_valid_life_timeout; start_timer(&cia->cia_life_timer, (cia->cia_valid_life - cia->cia_prefer_life)*DH6_LIFETIME_UNIT); cia->cia_state &= CIA_ADDR_VALID | 0x0f; if ( (db=dh6db_open(DH6CLI_BOOT)) < 0) log_sys(1133, "dbopen"); if (dh6db_locate(db, cia) == 0) dh6db_put(db, cia, R_CURSOR); else dh6db_put(db, cia, R_NOOVERWRITE); dh6db_sync(db); dh6db_close(db); } /* * When the valid lifetime expires */ void cia_valid_life_timeout( void * data ) { struct cli_ifaddr *cia = (struct cli_ifaddr *)data; DB *db; log_info("DHCP address %s becomes invalid", inet_ntop(AF_INET6, &(cia->cia_addr), 16, NULL)); dh6_remove_addr6(ifi_ifname(this_ifi), strlen(ifi_ifname(this_ifi)), &cia->cia_addr); if ( (db=dh6db_open(DH6CLI_BOOT)) < 0) log_sys(1134, "dbopen"); if (dh6db_locate(db, cia) == 0) { dh6db_del(db, cia, R_CURSOR); dh6db_sync(db); } dh6db_close(db); u_unlink(&client_list, cia); cia_destroy(cia); } int cli_multicast_solicit(char *which, ...) { struct sockaddr_in6 to6; u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg = (DH6_MESSAGE *)buf; int len; va_list ap; static u_int8_t Pbit = 1, Cbit = 1; va_start(ap, which); while ( *which ) { switch (*which++) { case 'P': Pbit = va_arg(ap, u_int8_t); break; case 'C': Cbit = va_arg(ap, u_int8_t); break; } } va_end(ap); bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, dh6sin_agent_group(), sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_AGENT_PORT); bzero((char *)msg, MAX_MSG_LEN); msg->sol.type = DH6_SOLICIT; msg->sol.Pbit = Pbit; msg->sol.Cbit = Cbit; len = sizeof(struct dh6_solicit); #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Solicit len:%d, to: %s, port:%d", len, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _resend_solicit: if (sendto(ll_sock.fd, msg, len, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != len) { if ( errno==EINTR ) goto _resend_solicit; if ( errno==EINVAL ) { log_info("Resending DHC Solicit"); goto _resend_solicit; } log_sys(1135, "sendto"); } /* * TODO: Should I send any extensions? */ return 0; } int cli_request_send( struct cli_ifaddr *cia, /* client entry */ char *which, /* which parameters */ ... ) { struct sockaddr_in6 to6; u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg = (DH6_MESSAGE *)buf; int len; va_list ap; static u_int8_t Cbit = 1, Sbit = 1; static struct in6_addr dest; static int fd = -1; /* you must set "fd" at the first time */ va_start(ap, which); while ( *which ) { switch (*which++) { case 'S': Sbit = va_arg(ap, u_int8_t); break; case 'C': Cbit = va_arg(ap, u_int8_t); break; case 'd': /* destination address */ memcpy(&dest, va_arg(ap, struct in6_addr *), IPV6_ADDR_LEN); break; case 'f': /* socket */ fd = va_arg(ap, int); break; } } va_end(ap); bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, &dest, sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_AGENT_PORT); bzero((char *)msg, sizeof(DH6_MESSAGE)); msg->req.type = DH6_REQUEST; msg->req.Sbit = Sbit; msg->req.Cbit = Cbit; msg->req.id = htons(cia->cia_id); if ( Sbit ) { set_request_server_addr(&msg->req, &cia->cia_svr->cs_addr); set_request_agent_addr(&msg->req, &cia->cia_rly->cr_addr); } else set_request_agent_addr(&msg->req, &cia->cia_svr->cs_addr); set_request_llocal_addr(&msg->req, ifi_lladdr(cia->cia_ifi)); if (cia->cia_extlen > 0) memcpy(request_ext(&msg->req), cia->cia_ext, cia->cia_extlen); len = sizeof(struct dh6_request) + IPV6_ADDR_LEN*(msg->req.Sbit+2) + cia->cia_extlen; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Request len:%d, to: %s, port:%d", len, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _resend_request: if (sendto(fd, msg, len, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != len) { if ( errno==EINTR ) goto _resend_request; if ( errno==EINVAL ) { log_info("Resending DHC Request"); goto _resend_request; } log_sys_warn(1136, "sendto"); } return 0; } int cli_release_send( struct cli_ifaddr *cia, /* client entry */ struct in6_addr *dest, /* destination address */ int Dbit) /* Direct or not */ { struct sockaddr_in6 to6; u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg = (DH6_MESSAGE *)buf; int len; int fd = (cia->cia_sk.fd>0) ? cia->cia_sk.fd : ll_sock.fd; bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, dest, sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_AGENT_PORT); bzero((char *)msg, sizeof(DH6_MESSAGE)); msg->rel.type = DH6_RELEASE; msg->rel.Dbit = Dbit; msg->rel.id = htons(cia->cia_id); memcpy(&msg->rel.AgtAddr, &cia->cia_rly->cr_addr, IPV6_ADDR_LEN); memcpy(&msg->rel.lladdr, ifi_lladdr(cia->cia_ifi), IPV6_ADDR_LEN); if (cia->cia_extlen > 0) memcpy(msg->rel.ext, cia->cia_ext, cia->cia_extlen); len = dh6_release_msg_len(&msg->rel) + cia->cia_extlen; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Release len:%d, to: %s, port:%d", len, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _resend_release: if (sendto(fd, msg, len, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != len) { if ( errno==EINTR ) goto _resend_release; if ( errno==EINVAL ) { log_info("Resending DHC Release"); goto _resend_release; } log_sys_warn(1137, "sendto"); } return 0; } ia->cia_ext = malloc(cia->cia_extlen); memcpy(cia->cidhcpv6-1.0/dh6_cli.h010060000015740003721000000110120625233634200144450ustar00yunzhouip00000400000004/* * dh6_cli.h DHCPv6 Client Data Structures * * Version: @(#)dh6_cli.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __DH6_CLI_H #define __DH6_CLI_H #define DH6CLI_CONF "dh6_client.conf" #define DH6CLI_BOOT "dh6_client.boot" #define CLI_CONF_PATH "/etc/" /* * Relay list */ struct cli_relay { struct cli_relay *next; struct cli_relay *prev; struct in6_addr cr_addr; /* Link-local address (net-order)*/ struct cli_server *cr_issvr; /* pointer to a server if it is */ }; /* * Server list */ struct cli_server { struct cli_server *next; struct cli_server *prev; struct in6_addr cs_addr; /* address (net-order) */ struct cli_relay *cs_rly; /* relay that it is associated with */ }; /* * Client address list */ struct cli_ifaddr { struct cli_ifaddr *next; struct cli_ifaddr *prev; IF_INFO *cia_ifi; /* interface information */ struct cli_server *cia_svr; /* server serving for the client */ struct cli_relay *cia_rly; /* agent on the same link */ struct in6_addr cia_addr; /* address (net order) */ u_int8_t cia_prfsize; /* prefix (net order) */ #define CIA_MSG_NONE 0x00 /* No messages */ #define CIA_REQ_WAIT 0x01 /* Request sent and waiting */ #define CIA_RPL_MORE 0x02 /* waiting more replies */ #define CIA_REQ_CLRD 0x04 /* Request cleared */ #define CIA_REL_WAIT 0x06 /* Release sent and waiting */ #define CIA_REL_CLRD 0x08 /* Release cleared */ #define CIA_ADDR_NONE 0x00 /* No address associated */ #define CIA_ADDR_TMP 0x10 /* Tentative address */ #define CIA_ADDR_PRFD 0x20 /* preferred address */ #define CIA_ADDR_VALID 0x40 /* valid address */ #define CIA_ADDR_INVAL 0x60 /* invalid address */ u_int8_t cia_state; /* Client state */ u_int16_t cia_id; /* transaction ID (host-order) */ u_int32_t cia_req_life; /* requested lifetime (host-order) */ u_int32_t cia_valid_life;/* seconds (host order) */ u_int32_t cia_prefer_life;/* seconds (host order) */ struct fd_list cia_sk; /* UDP socket for this client */ struct u_timer cia_xmit_timer;/* transmission timer */ u_int8_t cia_xmit_rc; /* retransmission counter */ /* transmission time can be returned by stop_timer() */ struct u_timer cia_life_timer;/* lifetime Timer */ int cia_extlen; /* length of extension */ void *cia_ext; /* extensions */ }; struct cli_record { char ifname[IFNAMSIZ]; struct in6_addr svr; /* server serving for the client */ struct in6_addr rly; /* agent on the same link */ struct in6_addr addr; /* address (net order) */ u_int8_t prfsize; /* prefix (net order) */ u_int8_t state; /* Client state */ u_int16_t id; /* transaction ID (host-order) */ u_int32_t req_life; /* requested lifetime (host-order) */ u_int32_t valid_life; /* seconds (host order) */ u_int32_t prefer_life; /* seconds (host order) */ }; extern inline int cia_addr_verified(struct cli_ifaddr *cia) { return( (cia->cia_state & CIA_ADDR_PRFD) || (cia->cia_state & CIA_ADDR_VALID) ); } extern struct cli_relay * cr_create( void ); extern void cr_destroy( struct cli_relay *); extern struct cli_relay * cr_get( struct in6_addr *); extern struct cli_server * cs_create( void ); extern void cs_destroy( struct cli_server *); extern struct cli_server * cs_get( struct in6_addr *); extern struct cli_ifaddr * cia_create( void ); extern void cia_destroy( struct cli_ifaddr *); extern struct cli_ifaddr * cia_get( struct in6_addr *); extern struct cli_ifaddr * cia_get_by_pairaddrs( struct in6_addr *, struct in6_addr *); #endif /* __DH6_CLI_H */ dhcpv6-1.0/dh6_clicmd.c010060000015740003721000000247430625233634200151430ustar00yunzhouip00000400000004/* * dh6_clicmd.c DHCPv6 Client Command * * Version: @(#)dh6_clicmd.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "localdefs.h" #include "u_timer.h" #include "dispatch.h" #include "u_buf.h" #include "dh6.h" #include "ext6.h" #include "dh6_if.h" #include "dh6_cli.h" #include "dh6_adm.h" #include "sock.h" extern char *optarg; extern int optind, opterr, optopt; int debug = 0; /* * Generate an error message with the printf facility. */ void p_error (int err, const char *ctl, ...) { char buf[1000]; va_list list; va_start (list,ctl); vsprintf (buf,ctl,list); printf("error %d: %s\n", err, buf); } main( int argc, char * argv[] ) { int optval; char op; u_int8_t buf[MAX_MSG_LEN]; ADM_MESSAGE *msg=(ADM_MESSAGE *)buf; DH6_MESSAGE *dh6=(DH6_MESSAGE *)(&msg->un.dh6.msg); char ifname[IFNAMSIZ]; int if_flag = 0; struct sockaddr_un su_svr, if_svr; int sockfd, su_svrlen, if_svrlen, msglen; IF_INFO *ifi; opterr = 0; while ((op = getopt(argc-1, argv+1, "d:D:i:I:")) != EOF) { switch (op) { #ifdef DH6_DEBUG case 'd': /* debug */ case 'D': /* debug */ debug = atoi(optarg); break; #endif case 'i': case 'I': /* interface */ strcpy(ifname, optarg); if_flag = 1; break; default: } } if ( argc<2 ) cmd_usage(); if ( strcmp(argv[1],"start")==0 ) { char cmd[50]; sprintf(cmd, "%sdh6cd -d%d", DH6_SERV_PATH, debug); system(cmd); exit(0); } else if ( strcmp(argv[1],"restart")==0 ) { char cmd[50]; sprintf(cmd, "%s stop", argv[0]); system(cmd); sleep(1); sprintf(cmd, "%s start -d%d", argv[0], debug); system(cmd); exit(0); } else if ( strcmp(argv[1],"stop")!=0 && strcmp(argv[1],"open")!=0 && strcmp(argv[1],"close")!=0 && strcmp(argv[1],"dbshow")!=0 && strcmp(argv[1],"solicit")!=0 && strcmp(argv[1],"request")!=0 && strcmp(argv[1],"release")!=0 ) cmd_usage(); bzero((char *) &su_svr, sizeof(su_svr)); su_svr.sun_family = AF_UNIX; strcpy(su_svr.sun_path, dh6cli_adm_name()); su_svrlen = strlen(su_svr.sun_path) + sizeof(su_svr.sun_family) + 1; bzero((char *) &if_svr, sizeof(if_svr)); if_svr.sun_family = AF_UNIX; strcpy(if_svr.sun_path, dh6cli_adm_server_name(ifname)); if_svrlen = strlen(if_svr.sun_path) + sizeof(if_svr.sun_family) + 1; /* * Open a socket (an UNIX domain stream socket). * and connect to server later */ if ( (sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) p_error(1201, strerror(errno)); memset(buf, 0, MAX_MSG_LEN); if ( strcmp(argv[1],"stop")==0 ) { if (connect(sockfd, (struct sockaddr *)&su_svr, su_svrlen) < 0) p_error(1202, strerror(errno)); msg->cmd = ADM_CMD_STOP; msg->len = 0; msglen = 4; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } if ( strcmp(argv[1],"open")==0 ) { if (connect(sockfd, (struct sockaddr *)&su_svr, su_svrlen) < 0) p_error(1203, strerror(errno)); msg->cmd = ADM_OPEN_DHCPV6; msg->len = strlen(argv[2]); strcpy(msg->un.data, argv[2]); msglen = 4 + msg->len; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } if ( !if_flag ) { p_error(1204, "interface name missing"); goto out; } u_free_list_init(); init_ifi_table(); get_ifi_table(); if ((ifi=seek_ifi_byname(ifname, strlen(ifname))) == NULL) { p_error(1205, "interface not found"); goto out; } if ( strcmp(argv[1],"close")==0 ) { if (connect(sockfd, (struct sockaddr *)&if_svr, if_svrlen) < 0) p_error(1206, strerror(errno)); msg->cmd = ADM_CMD_STOP; msg->len = 0; msglen = 4; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } opterr = 0; if ( strcmp(argv[1],"dbshow")==0 ) { struct in6_addr addr; if (connect(sockfd, (struct sockaddr *)&if_svr, if_svrlen) < 0) p_error(1206, strerror(errno)); msg->cmd = ADM_SHOW_DB; while ((op=getopt(argc-1,argv+1,"s:S:a:A:v:V:"))!=EOF) { switch (op) { case 's': case 'S': inet_pton(AF_INET6, optarg, &addr); memcpy(&msg->un.cdb.server, &addr, IPV6_ADDR_LEN); msg->bit0 = 1; break; case 'a': case 'A': inet_pton(AF_INET6, optarg, &addr); memcpy(&msg->un.cdb.agent, &addr, IPV6_ADDR_LEN); msg->bit1 = 1; break; case 'v': case 'V': inet_pton(AF_INET6, optarg, &addr); memcpy(&msg->un.cdb.client, &addr, IPV6_ADDR_LEN); msg->bit2 = 1; break; } } msg->len = ADM_CLIDB_LEN; msglen = 4 + msg->len; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } if ( strcmp(argv[1],"solicit")==0 ) { int Pbit = 0, Cbit = 0; if (connect(sockfd, (struct sockaddr *)&if_svr, if_svrlen) < 0) p_error(1207, strerror(errno)); while ((op = getopt(argc-1, argv+1, "pc")) != EOF) { switch (op) { case 'p': case 'P': Pbit = 1; break; case 'c': case 'C': Cbit = 1; break; } } msg->cmd = ADM_DH6_MSG; msg->un.dh6.lport = DH6_CLIENT_PORT; msg->un.dh6.fport = DH6_AGENT_PORT; memcpy(&msg->un.dh6.laddr, ifi_lladdr(ifi), IPV6_ADDR_LEN); memcpy(&msg->un.dh6.faddr, dh6sin_agent_group(), IPV6_ADDR_LEN); dh6->sol.type = DH6_SOLICIT; dh6->sol.Pbit = Pbit; dh6->sol.Cbit = Cbit; msg->len = sizeof(struct dh6_solicit) + ADM_DH6MSG_HDRLEN; msglen = msg->len + 4; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } if ( strcmp(argv[1],"request")==0 ) { struct in6_addr server, agent, client; u_int8_t *ext = NULL; int extlen = 0; int prefer = 0, valid = 0, Qbit = 0, v_flag = 0; if (connect(sockfd, (struct sockaddr *)&if_svr, if_svrlen) < 0) p_error(1208, strerror(errno)); msg->cmd = ADM_DH6_MSG; msg->un.dh6.lport = DH6_CLIENT_PORT; msg->un.dh6.fport = DH6_AGENT_PORT; memcpy(&msg->un.dh6.laddr, ifi_lladdr(ifi), IPV6_ADDR_LEN); dh6->req.type = DH6_REQUEST; while ((op=getopt(argc-1,argv+1,"s:S:a:A:v:V:l:L:cCqQ"))!=EOF) { switch (op) { case 's': case 'S': dh6->req.Sbit = 1; inet_pton(AF_INET6, optarg, &server); set_request_server_addr(&dh6->req, &server); break; case 'a': case 'A': inet_pton(AF_INET6, optarg, &agent); set_request_agent_addr(&dh6->req, &agent); memcpy(&msg->un.dh6.faddr, &agent, IPV6_ADDR_LEN); break; case 'v': case 'V': inet_pton(AF_INET6, optarg, &client); v_flag = 1; break; case 'l': prefer = atoi(optarg); break; case 'L': valid = atoi(optarg); break; case 'c': case 'C': dh6->req.Cbit = 1; break; case 'q': case 'Q': Qbit = 1; break; } } set_request_llocal_addr(&dh6->req, ifi_lladdr(ifi)); msg->len = ADM_DH6MSG_HDRLEN + sizeof(struct dh6_request) + IPV6_ADDR_LEN*(dh6->req.Sbit+2); append_addr_ext6(ext, &extlen, (v_flag) ? &client : NULL, 0, prefer, valid, NULL, Qbit, 0, 0); if ( extlen != 0 && ext != NULL ) { memcpy(buf+4+msg->len, ext, extlen); msg->len += extlen; } msglen = msg->len + 4; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } if ( strcmp(argv[1],"release")==0 ) { struct in6_addr server, agent; if (connect(sockfd, (struct sockaddr *)&if_svr, if_svrlen) < 0) p_error(1209, strerror(errno)); msg->cmd = ADM_DH6_MSG; msg->un.dh6.lport = DH6_CLIENT_PORT; msg->un.dh6.fport = DH6_AGENT_PORT; memcpy(&msg->un.dh6.laddr, ifi_lladdr(ifi), IPV6_ADDR_LEN); dh6->rel.type = DH6_RELEASE; while ((op=getopt(argc-1,argv+1,"s:S:a:A:tT")) != EOF) { switch (op) { case 's': case 'S': inet_pton(AF_INET6, optarg, &server); memcpy(&msg->un.dh6.faddr, &server, IPV6_ADDR_LEN); break; case 'a': case 'A': inet_pton(AF_INET6, optarg, &agent); memcpy(&dh6->rel.AgtAddr, &agent, IPV6_ADDR_LEN); break; case 'x': case 'X': dh6->rel.id = htons(atoi(optarg)); break; case 't': case 'T': dh6->rel.Dbit = 1; break; } } memcpy(&dh6->rel.lladdr, ifi_lladdr(ifi), IPV6_ADDR_LEN); msg->len = ADM_DH6MSG_HDRLEN + dh6_release_msg_len(&dh6->rel); msglen = msg->len + 4; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } out: close(sockfd); exit(0); } cmd_usage( void ) { printf("usage: dh6cc start -d\n"); printf(" dh6cc restart -d\n"); printf(" dh6cc open -i\n"); printf(" dh6cc close -i\n"); printf(" dh6sc dbshow -s -a -v\n"); printf(" dh6cc solicit -i -p -c\n"); printf(" dh6cc request -i -s -a -c -v -q -l -L\n"); printf(" dh6cc release -i -s -a -x -t\n"); printf(" dh6cc stop\n"); exit(1); } /* * send a message to server */ int cmd_sendto_serv( int sockfd, ADM_MESSAGE *msg, int msglen ) { if ( send(sockfd, msg, msglen, 0) != msglen) { p_error(1210, strerror(errno)); return -1; } return 0; } dhcpv6-1.0/dh6_client.conf010060000015740003721000000017070625233634200156640ustar00yunzhouip00000400000004# # dh6_client.conf DHCPv6 Client Configuration File # # Version: @(#)dh6_client.conf 1.0 Dec-8-96 # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # This program is distributed WITHOUT ANY WARRANTY and even the implied # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # # Many thanks to Jim Bound in Digital Equipment Corp. # Appreciate any further work on this release. # # Authors: Yunzhou Li (yunzhou@iol.unh.edu) # # SolicitPbit 1 SolicitCbit 1 RequestLife 8 RequestQbit 0 dhcpv6-1.0/dh6_db.c010060000015740003721000000104160625233634200142650ustar00yunzhouip00000400000004/* * dh6_db.c Routines for DHCPv6 Database * * Version: @(#)dh6_db.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_adm.h" #include "dh6_db.h" #include "parse.h" u_int16_t key_prefix = 0x80FE; /* ntohs(0xFE80) */ inline int dh6db_copy(void *dst, void *src, int len) { u_int8_t *dst2 = dst, *src2 = src; int i; for (i = 0; i < len; i++) dst2[i] = src2[i]; } inline DB * dh6db_open(const char *fname) { char name[100]; DB *db; sprintf(name, "%s%s", DH6_SERV_PATH, fname); db = dbopen(name, O_CREAT | O_RDWR | O_NONBLOCK, S_IRUSR | S_IWUSR, DB_RECNO, NULL); /* ??? */ #ifdef DH6_DEBUG if ( look_db_more() ) log_info("open database %s fd:%d", name, db->fd(db)); #endif return db; } inline int dh6db_close(DB *db) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("close database fd:%d", db->fd(db)); #endif return db->close(db); } inline int dh6db_fd(const DB *db) { return db->fd(db); } inline int dh6db_sync(const DB *db) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("sync database fd:%d", db->fd(db)); #endif return db->sync(db, 0); } int dh6db_del(DB *db, void *entry, u_int flags) { int ret = 0; DBT key; #ifdef DH6_DEBUG if ( look_db_more() ) log_info("delete a record in database fd:%d", db->fd(db)); #endif dh6db_alloc_key(&key, entry); ret = db->del(db, &key, flags); free(key.data); return ret; } int dh6db_get(DB *db, void *entry, u_int flags) { int ret = 0; DBT rec, key; dh6db_alloc_key(&key, entry); ret = db->get(db, &key, &rec, flags); free(key.data); if (ret == 0 && rec.size > 0) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("get a record (size:%d) in database fd:%d", rec.size, db->fd(db)); #endif dh6db_convert_rec(&rec, entry); return 0; } else return -1; } int dh6db_put(DB *db, void *entry, u_int flags) { int ret; DBT rec, key; dh6db_alloc_rec(&rec, entry); dh6db_alloc_key(&key, entry); #ifdef DH6_DEBUG if ( look_db_more() ) log_info("put a record (size:%d) in database fd:%d", rec.size, db->fd(db)); #endif ret = db->put(db, &key, &rec, flags); free(rec.data); free(key.data); return ret; } int dh6db_locate(DB *db, void *entry) { int ret; DBT rec, key; dh6db_alloc_key(&key, entry); ret = db->seq(db, &key, &rec, R_CURSOR); free(key.data); if (ret == 0 && rec.size > 0) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("locate a record (size:%d) in database fd:%d", rec.size, db->fd(db)); #endif dh6db_convert_rec(&rec, entry); return 0; } else return -1; } int dh6db_skip_next(DB *db, void *entry) { int ret; DBT rec, key; memset(&rec, 0, sizeof(rec)); memset(&key, 0, sizeof(key)); ret = db->seq(db, &key, &rec, R_NEXT); if (ret == 0 && rec.size > 0) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("skip to next record (size:%d) in db fd:%d", rec.size, db->fd(db)); #endif dh6db_convert_rec(&rec, entry); return 0; } else return -1; } int dh6db_skip_prev(DB *db, void *entry) { int ret; DBT rec, key; memset(&rec, 0, sizeof(rec)); memset(&key, 0, sizeof(key)); ret = db->seq(db, &key, &rec, R_PREV); if (ret == 0 && rec.size > 0) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("skip to prev record (size:%d) in db fd:%d", rec.size, db->fd(db)); #endif dh6db_convert_rec(&rec, entry); return 0; } else return -1; } dhcpv6-1.0/dh6_db.h010060000015740003721000000020460625233634200142720ustar00yunzhouip00000400000004/* * dh6_db.h External Routines for DHCPv6 Database * * Version: @(#)dh6_db.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __DB6_DB_H #define __DB6_DB_H #define KPREFIX_LEN 2 extern u_int16_t key_prefix; extern DB * dh6db_open(const char *); #endif dhcpv6-1.0/dh6_if.c010060000015740003721000000112130625233634200142720ustar00yunzhouip00000400000004/* * dh6_if.c Routines for DHCPv6 Interfaces * * Version: @(#)dh6_if.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "localdefs.h" #include "u_timer.h" #include "dispatch.h" #include "u_buf.h" #include "dh6.h" #include "ext6.h" #include "dh6_if.h" #include "dh6_cli.h" #include "dh6_adm.h" UNION_LIST ifi_table; void init_ifi_table( void ) { ifi_table.ifi.head = NULL; ifi_table.ifi.tail = NULL; } int get_ifi_table( void ) { u_char buf[8192]; u_char *buf_end; struct ifconf ifc; struct ifreq *ifr; struct if_info *ifi; struct sockaddr_in6 *sin6; int s; if ((s=socket(AF_INET6, SOCK_DGRAM, 0)) < 0) log_sys(201, "socket"); ifc.ifc_len = sizeof(buf); ifc.ifc_buf = (char *)buf; if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) log_fatal(202,"SIOCGIFCONF failed"); buf_end = buf + ifc.ifc_len; ifr = ifc.ifc_req; while ((u_char *)ifr < buf_end) { sin6 = (struct sockaddr_in6 *)&ifr->ifr_addr; #ifdef DH6_DEBUG if ( look_xmit_more() ) { if ( ifr->ifr_addr.sa_family == AF_LINK ) { struct sockaddr_dl *sdl = (struct sockaddr_dl *)sin6; char ss[20]; strncpy(ss, sdl->sdl_data, sdl->sdl_nlen); log_info("AF_LINK: %s index %d", ss, sdl->sdl_index); } else if ( ifr->ifr_addr.sa_family == AF_INET6 ) log_info("AF_INET6: %s", inet_ntop(AF_INET6,&sin6->sin6_addr,16,NULL)); else if ( ifr->ifr_addr.sa_family == AF_INET ) log_info("AF_INET: %s", inet_ntoa(((struct sockaddr_in*)sin6)->sin_addr)); } #endif if ( ifr->ifr_addr.sa_family == AF_INET6 && IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ) { if ( (ifi = u_alloc_node()) == NULL ) return -1; memset(ifi, 0, sizeof(struct if_info)); strcpy(ifi->ifi_name, ifr->ifr_name); memcpy(&ifi->ifi_lladdr, &sin6->sin6_addr, sizeof(struct in6_addr)); u_queue_tail(&ifi_table, ifi); } ifr = (struct ifreq *)((char *)ifr + sizeof(ifr->ifr_name) + (sizeof(ifr->ifr_addr) > ifr->ifr_addr.sa_len ? sizeof(ifr->ifr_addr) : ifr->ifr_addr.sa_len )); } ifr = ifc.ifc_req; while ((u_char *)ifr < buf_end) { struct sockaddr_dl *sdl; if ( ifr->ifr_addr.sa_family != AF_LINK ) goto get_ifi_table_skip; sdl = (struct sockaddr_dl *)&ifr->ifr_addr; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { if ( !strncmp(ifi->ifi_name, sdl->sdl_data, sdl->sdl_nlen) ) { ifi->ifi_ifindex = sdl->sdl_index; } } get_ifi_table_skip: ifr = (struct ifreq *)((char *)ifr + sizeof(ifr->ifr_name) + (sizeof(ifr->ifr_addr) > ifr->ifr_addr.sa_len ? sizeof(ifr->ifr_addr) : ifr->ifr_addr.sa_len )); } close(s); return 0; } struct if_info * seek_ifi_byname( char *name, int len ) { struct if_info *ifi; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { if ( !strncmp(ifi->ifi_name,name,len) ) return ifi; } return NULL; } struct if_info * seek_ifi_byindex( int ifindex ) { struct if_info *ifi; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { if ( ifi->ifi_ifindex = ifindex ) return ifi; } return NULL; } struct if_info * seek_ifi_bypid( pid_t pid ) { struct if_info *ifi; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { if ( ifi->ifi_pid == pid ) return ifi; } return NULL; } void ifi_kill_dhcpv6( void ) { struct if_info *ifi; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { if ( ifi->ifi_dh6 ) kill(ifi->ifi_pid, SIGKILL); } } void print_ifi_table( void ) { struct if_info *ifi; int n = 1; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { log_info("if%d: name = %s, index = %d", n++, ifi->ifi_name, ifi->ifi_ifindex); log_info(" lladdr = %s", inet_ntop(AF_INET6,&(ifi->ifi_lladdr),16,NULL)); log_info(" pid = %d, dhcpv6: %d", ifi->ifi_pid, ifi->ifi_dh6); } } char *)ifr < buf_end) { sin6 = (struct sockaddr_in6 *)&ifr->ifr_addr; #ifdef DH6_DEBUG if ( look_xmit_more() ) { if ( ifr->ifr_addr.sa_family == AF_LINK ) { struct sockaddr_dl *sdl = (struct sockaddr_dl *)sin6; char ss[20]; strncpy(ss, sdl->sdl_data, sdl->sdl_nlen); log_info("AF_LINK: %s index %d", ss, sdl->sdl_inddhcpv6-1.0/dh6_if.h010060000015740003721000000041540625233634200143050ustar00yunzhouip00000400000004/* * dh6_if.h DHCPv6 Interface Structures * * Version: @(#)dh6_if.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __ND6_IF_H #define __ND6_IF_H /* * per-interface information * * XXX may need to handle multiple link local addresses per interface */ struct if_info { struct if_info *next; /* next interface */ struct if_info *prev; /* previous interface */ char ifi_name[IFNAMSIZ]; /* interface name */ struct in6_addr ifi_lladdr; /* link-local address */ int ifi_ifindex; /* interface index */ UNION_LIST ifi_dhcpv6; /* DHCPv6 addresses */ pid_t ifi_pid; /* DHCPv6 procedd ID */ u_int16_t ifi_dh6:1, /* if DHCPv6 is running */ rsvd:15; }; typedef struct if_info IF_INFO; /* interface structure */ #define ifi_ifname(ifi) ((ifi)->ifi_name) #define ifi_ifindex(ifi) ((ifi)->ifi_ifindex) #define ifi_lladdr(ifi) &((ifi)->ifi_lladdr) extern void init_ifi_table( void ); extern int get_ifi_table( void ); extern struct if_info * seek_ifi_byname(char *, int); extern struct if_info * seek_ifi_byindex(int); extern struct if_info * seek_ifi_bypid(pid_t); extern int if_info_kernel_set ( int, char *, int, int ); extern int if_info_kernel_get ( int, char *, int, int * ); extern void print_ifi_table( void ); extern void ifi_kill_dhcpv6( void ); #endif /* __ND6_IF_H */ dhcpv6-1.0/dh6_newaddress010060000015740003721000000023120625233634200156120ustar00yunzhouip00000400000004# # dh6_newaddress DHCPv6 Server Addresses to be assigned # # Version: @(#)dh6_newaddress 1.0 Dec-8-96 # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # This program is distributed WITHOUT ANY WARRANTY and even the implied # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # # Many thanks to Jim Bound in Digital Equipment Corp. # Appreciate any further work on this release. # # Authors: Yunzhou Li (yunzhou@iol.unh.edu) # # From "5f02:3000:84b1:7600:0:900:2b39:b5e0" To "5f02:3000:84b1:7600:0:900:2b39:b5ef" Prefix 128 From "5f02:3000:84b1:7600:0:900:2b39:b6e0" To "5f02:3000:84b1:7600:0:900:2b39:b6ef" Prefix 128 From "5f02:3000:84b1:7600:0:900:2b39:b7e0" To "5f02:3000:84b1:7600:0:900:2b39:b7ef" Prefix 128 dhcpv6-1.0/dh6_relay.conf010060000015740003721000000015620625233634200155210ustar00yunzhouip00000400000004# # dh6_relay.conf DHCPv6 Relay Configuration File # # Version: @(#)dh6_relay.conf 1.0 Dec-8-96 # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # This program is distributed WITHOUT ANY WARRANTY and even the implied # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # # Many thanks to Jim Bound in Digital Equipment Corp. # Appreciate any further work on this release. # # # To be defined further dhcpv6-1.0/dh6_rly.c010060000015740003721000000746440625233634200145230ustar00yunzhouip00000400000004/* * dh6_rly.c DHCPv6 Relay Agent Daemon * * Version: @(#)dh6_rly.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_if.h" #include "dh6_rly.h" #include "dh6_adm.h" #include "sock.h" void rly_run_unix_server( void * ); void rly_adm_msgrcv( void * ); void rly_dh6_msg_rcv( void * ); void rly_dh6_multicast_rcv( void * ); void rs_advertise_timeout( void * ); struct fd_list multi_sock; /* multicast socket */ struct fd_list unix_sock; /* unix socket */ struct poll_list poll_unix; extern UNION_LIST ifi_table; UNION_LIST server_list, relay_list; int debug = 0; int quit_flag = 0; /* * There is a UDP socket for each relay address * There are one multicast socket; */ void main( int argc, char *argv[] ) { struct ipv6_mreq mr6; int optval; char op; struct rly_ifaddr *ria; opterr = 0; while ((op = getopt(argc, argv, "d:D:")) != EOF) { switch (op) { #ifdef DH6_DEBUG case 'd': /* debug */ case 'D': /* debug */ debug = atoi(optarg); break; #endif default: } } if ( daemon_init() < 0 ) log_fatal(2001, "daemon init fail"); if (debug > 0) openlog ("", LOG_CONS, LOG_DAEMON); else openlog (argv[0], 0, LOG_DAEMON); u_free_list_init(); begin_timing(); init_ifi_table(); get_ifi_table(); #ifdef DH6_DEBUG if ( look_cache() ) { log_info("debug = %d", debug); print_ifi_table(); } #endif dh6_relay_init(); rly_get_addr_table(); #ifdef DH6_DEBUG if ( look_cache() ) rly_print_addr_table(); #endif if ( (unix_sock.fd=open_unix_sock(dh6rly_adm_server_name())) < 0 ) log_fatal(2002, "open unix socket fail"); init_poll(&poll_unix); poll_unix.data = &unix_sock; poll_unix.function = rly_run_unix_server; add_poll(&poll_unix); if ( (multi_sock.fd=rly_udp6_socket(NULL)) < 0) log_fatal(2003, "open UDP6 socket fail"); #ifdef IPV6_TXINFO_WORK optval = 1; if (setsockopt(multi_sock.fd, IPPROTO_IPV6, IPV6_TXINFO, (char *)&optval, sizeof(optval)) < 0) log_fatal(2004, "IPV6_TXINFO fail"); #endif optval = 1; if (setsockopt(multi_sock.fd, IPPROTO_IPV6, IPV6_RXINFO, (char *)&optval, sizeof(optval)) < 0) log_fatal(2005, "IPV6_RXINFO fail"); init_fdp(&multi_sock); multi_sock.data = &multi_sock; multi_sock.function = rly_dh6_multicast_rcv; add_fdp(&multi_sock); /* open a socket for each relay address */ for (ria = relay_list.ria_head; ria != NULL; ria = ria->next) { if ( (ria->ria_sk.fd=rly_udp6_socket(&ria->ria_addr)) < 0) log_fatal(2006, "open UDP6 socket fail"); memcpy(&mr6.ipv6mr_interface, &ria->ria_addr, sizeof(struct in6_addr)); /* join relay multicast group */ memcpy(&mr6.ipv6mr_multiaddr, dh6sin_relay_group(), sizeof(struct in6_addr)); if (setsockopt(ria->ria_sk.fd, IPPROTO_IPV6, IP_ADD_MEMBERSHIP, (caddr_t)&mr6, sizeof(mr6)) < 0) log_fatal(2007, "relay IP_ADD_MEMBERSHIP fail"); /* join agent multicast group */ memcpy(&mr6.ipv6mr_multiaddr, dh6sin_agent_group(), sizeof(struct in6_addr)); if (setsockopt(ria->ria_sk.fd, IPPROTO_IPV6, IP_ADD_MEMBERSHIP, (caddr_t)&mr6, sizeof(mr6)) < 0) log_fatal(2008, "agent IP_ADD_MEMBERSHIP fail"); if (setsockopt(ria->ria_sk.fd, IPPROTO_IPV6, IP_MULTICAST_IF, (char *)&ria->ria_addr, IPV6_ADDR_LEN) < 0) log_fatal(2009, "IP_MULTICAST_IF fail"); init_fdp(&ria->ria_sk); ria->ria_sk.data = ria; ria->ria_sk.function = rly_dh6_msg_rcv; add_fdp(&ria->ria_sk); } read_dh6_relay_conf(); /* read from "dh6_relay.conf" */ for (;;) { dispatch(); if ( quit_flag ) break; } end_timing(); del_poll(&poll_unix); close_unix_sock(unix_sock.fd, dh6rly_adm_server_name()); del_fdp(&multi_sock); close(multi_sock.fd); for (ria = relay_list.ria_head; ria != NULL; ria = ria->next) { if (ria->ria_sk.fd > 0) { del_fdp(&ria->ria_sk); close(ria->ria_sk.fd); } } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("exit from %s", argv[0]); #endif closelog(); exit(0); } static inline struct rly_server * rs_create( void ) { struct rly_server *rs; if ( (rs=u_alloc_node()) == NULL ) return NULL; rs->rs_ifi = NULL; init_timer(&rs->rs_timer); rs->rs_timer.data = (void *)rs; rs->rs_timer.function = (void (*)(void *))rs_advertise_timeout; return rs; } static inline void rs_destroy( struct rly_server *rs ) { u_free_node(rs); } static struct rly_server * rs_get( struct in6_addr *addr ) { struct rly_server *rs; for (rs = server_list.rs_head; rs != NULL; rs = rs->next) { if ( !memcmp(&rs->rs_addr, addr, IPV6_ADDR_LEN) ) return rs; } return NULL; } static struct rly_ifaddr * ria_create( void ) { struct rly_ifaddr *ria; if ( (ria=u_alloc_node()) == NULL ) return NULL; ria->ria_ifi = NULL; ria->ria_sk.fd = -1; return ria; } static inline void ria_destroy( struct rly_ifaddr *ria ) { if (ria->ria_sk.fd > 0) { del_fdp(&ria->ria_sk); close( ria->ria_sk.fd ); } u_free_node(ria); } struct rly_ifaddr * ria_get(struct in6_addr *addr) { struct rly_ifaddr *ria; for (ria = relay_list.ria_head; ria != NULL; ria = ria->next) { if ( !memcmp(&ria->ria_addr, addr, IPV6_ADDR_LEN) ) return ria; } return NULL; } struct rly_ifaddr * rly_get_replay_byifindex(int ifindex) { struct rly_ifaddr *ria; for (ria = relay_list.ria_head; ria != NULL; ria = ria->next) { if (ifi_ifindex(ria->ria_ifi) == ifindex) return ria; } return NULL; } int dh6_relay_init( void ) { server_list.chain.head = NULL; server_list.chain.head = NULL; relay_list.chain.tail = NULL; relay_list.chain.tail = NULL; } int rly_get_addr_table( void ) { u_char buf[8192]; u_char *buf_end; struct ifconf ifc; struct ifreq *ifr; struct if_info *ifi; struct rly_ifaddr *ria; struct sockaddr_in6 *sin6; int s; if ((s=socket(AF_INET6, SOCK_DGRAM, 0)) < 0) log_sys(2010, "socket"); ifc.ifc_len = sizeof(buf); ifc.ifc_buf = (char *)buf; if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) log_fatal(2011,"SIOCGIFCONF failed"); buf_end = buf + ifc.ifc_len; ifr = ifc.ifc_req; while ((u_char *)ifr < buf_end) { sin6 = (struct sockaddr_in6 *)&ifr->ifr_addr; if ( ifr->ifr_addr.sa_family == AF_INET6 && !IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ) { if ( (ria = u_alloc_node()) == NULL ) return -1; memset(ria, 0, sizeof(struct rly_ifaddr)); ria->ria_ifi = seek_ifi_byname(ifr->ifr_name, strlen(ifr->ifr_name)); memcpy(&ria->ria_addr, &sin6->sin6_addr, sizeof(struct in6_addr)); u_queue_tail(&relay_list, ria); } ifr = (struct ifreq *)((char *)ifr + sizeof(ifr->ifr_name) + (sizeof(ifr->ifr_addr) > ifr->ifr_addr.sa_len ? sizeof(ifr->ifr_addr) : ifr->ifr_addr.sa_len )); } close(s); return 0; } #ifdef DH6_DEBUG int rly_print_addr_table( void ) { struct rly_ifaddr *ria; int n = 1; log_info("Server table:"); for (ria = relay_list.ria_head; ria != NULL; ria = ria->next) { log_info(" addr: %s, if: %s", inet_ntop(AF_INET6,&ria->ria_addr,16,NULL), ifi_ifname(ria->ria_ifi)); } return 0; } #endif struct rly_ifaddr * rly_get_relay_byifname(char *name, int len) { struct rly_ifaddr *ria; for (ria = relay_list.ria_head; ria != NULL; ria = ria->next) { if ( !memcmp(ifi_ifname(ria->ria_ifi), name, len) ) return ria; } return NULL; } struct rly_ifaddr * rly_get_relay_byifindex(int ifindex) { struct rly_ifaddr *ria; for (ria = relay_list.ria_head; ria != NULL; ria = ria->next) { if (ifi_ifindex(ria->ria_ifi) == ifindex) return ria; } return NULL; } /* * to receive DHCPv6 messages */ void rly_dh6_multicast_rcv( void * data ) { struct fd_list *sock = (struct fd_list *)data; u_int8_t buf[MAX_MSG_LEN]; u_int8_t ctrldata[64]; for (;;) { struct iovec aiov[1]; struct msghdr msg; struct cmsghdr *cmsg = (struct cmsghdr *)ctrldata; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)buf; struct sockaddr_in6 sin6; int len; msg.msg_name = (caddr_t)&sin6; msg.msg_namelen = sizeof(struct sockaddr_in6) ; msg.msg_iov = aiov; msg.msg_iovlen = 1; aiov[0].iov_base = buf; aiov[0].iov_len = MAX_MSG_LEN; msg.msg_control = ctrldata; msg.msg_controllen = sizeof(ctrldata); msg.msg_flags = 0; len = recvmsg(sock->fd, &msg, 0); /* * It is very possible for signal SIGCHLD to interrupt this * slow system call recvfrom */ __ugly: if (len == 0) return; else if (len < 0) { if (errno == EINTR) goto __ugly; if (errno == EWOULDBLOCK) return; /* no more messages */ log_sys(2012, "recvfrom"); } switch ( dh6msg->msg.type ) { case DH6_SOLICIT: rly_solicit_rcv(&msg, len); break; case DH6_ADVERTISE: rly_advertise_rcv(&msg, len); break; default: log_warn(2013,"unknown message %u", dh6msg->msg.type); } } return; } /* * On receiving DHC Solicit message */ int rly_solicit_rcv(struct msghdr *msg, int len) { struct sockaddr_in6 *src_addr = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; struct in6_pktinfo *pktinfo; struct rly_ifaddr *ria; int extlen = 0; void *ext = NULL; struct in6_addr *svr_addrs; int svr_cnt = 0; struct rly_server *rs; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving Solicit message from %s", inet_ntop(AF_INET6, &src_addr->sin6_addr, 16, NULL)); #endif if ((pktinfo=cmsg_get(msg, IPPROTO_IPV6, IPV6_RXINFO)) == NULL) { log_warn(2014, "IPV6_RXINFO not found"); return -1; } if ((ria=rly_get_relay_byifindex(pktinfo->ipi6_ifindex)) == NULL) { log_warn(2015, "relay address entry cannot be located"); return -1; } if ( !dh6msg->sol.Pbit || server_list.rs_head ==NULL ) { /* forward it to server */ rly_solicit_send(&ria->ria_addr, &src_addr->sin6_addr, dh6msg->sol.Cbit, len - dh6_solicit_msg_len(&dh6msg->sol), solicit_ext(&dh6msg->sol)); return 0; } /* * Now I can glean server addresses from my cache * and build an Advertise message to the client */ #ifdef TODO build_extensions_if_any(&ext, &extlen); #endif for (rs = server_list.rs_head; rs != NULL; rs = rs->next) { /* * DHCP Advertise messages constructed by DHCP relays * from cached server addresses MUST NOT include a * server address on the same link as the soliciting client. */ if (rs->rs_ifi == ria->ria_ifi) continue; svr_cnt++; } svr_addrs = (struct in6_addr *)malloc(svr_cnt*IPV6_ADDR_LEN); if (svr_addrs == NULL) return -1; for (rs = server_list.rs_head; rs != NULL; rs = rs->next) { if (rs->rs_ifi == ria->ria_ifi) continue; memcpy(svr_addrs, &rs->rs_addr, IPV6_ADDR_LEN); } rly_advertise_send(ria, &src_addr->sin6_addr, svr_cnt, svr_addrs, extlen, ext); free(svr_addrs); free(ext); return 0; } /* * On receiving DHC Advertise message */ int rly_advertise_rcv(struct msghdr *msg, int len) { struct sockaddr_in6 *src_addr = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; struct in6_pktinfo *pktinfo; struct rly_ifaddr *ria; struct rly_server *rs; struct in6_addr *svr_addrs; IF_INFO *ifi; int i; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving Advertise message from %s", inet_ntop(AF_INET6, &src_addr->sin6_addr, 16, NULL)); #endif if ((pktinfo=cmsg_get(msg, IPPROTO_IPV6, IPV6_RXINFO)) == NULL) { log_warn(2016, "IPV6_RXINFO not found"); return -1; } if ((ifi=seek_ifi_byindex(pktinfo->ipi6_ifindex)) == NULL) { log_warn(2017, "interface for receiving advertise not located"); return -1; } if ((ria=ria_get(&dh6msg->adv.AgtAddr)) == NULL) { log_warn(2019, "Agent address not one of the interfaces"); return -1; } /* forward it to client if requested by client */ if ( dh6msg->adv.Lbit ) rly_request_fwd(ria, len, dh6msg); svr_addrs = get_advertise_server_addr(&dh6msg->adv); for (i=0; iadv.SvrCnt; i++) { if ( !(rs=rs_get(svr_addrs)) ) { if ( (rs=rs_create()) == NULL ) return -1; u_queue_head(&server_list, rs); rs->rs_ifi = ifi; memcpy(&rs->rs_addr, svr_addrs, IPV6_ADDR_LEN); rs->rs_lifetime = dh6msg->adv.lifetime; start_timer(&rs->rs_timer, rs->rs_lifetime*DH6_SVR_TIMEUNIT); } else { rs->rs_ifi = ifi; rs->rs_lifetime = dh6msg->adv.lifetime; restart_timer(&rs->rs_timer, rs->rs_lifetime*DH6_SVR_TIMEUNIT); } svr_addrs++; } return 0; } /* * to receive DHCPv6 messages */ void rly_dh6_msg_rcv( void * data ) { struct rly_ifaddr *ria = (struct rly_ifaddr *)data; u_int8_t buf[MAX_MSG_LEN]; u_int8_t ctrldata[64]; for (;;) { struct iovec aiov[1]; struct msghdr msg; struct cmsghdr *cmsg = (struct cmsghdr *)ctrldata; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)buf; struct sockaddr_in6 sin6; int len; msg.msg_name = (caddr_t)&sin6; msg.msg_namelen = sizeof(struct sockaddr_in6) ; msg.msg_iov = aiov; msg.msg_iovlen = 1; aiov[0].iov_base = buf; aiov[0].iov_len = MAX_MSG_LEN; msg.msg_control = ctrldata; msg.msg_controllen = sizeof(ctrldata); msg.msg_flags = 0; len = recvmsg(ria->ria_sk.fd, &msg, 0); /* * It is very possible for signal SIGCHLD to interrupt this * slow system call recvfrom */ __ugly2: if (len == 0) return; else if (len < 0) { if (errno == EINTR) goto __ugly2; if (errno == EWOULDBLOCK) return; /* no more messages */ log_sys(2020, "recvfrom"); } switch ( dh6msg->msg.type ) { case DH6_REQUEST: rly_request_rcv(ria, &msg, len); break; case DH6_REPLY: rly_reply_rcv(ria, &msg, len); break; default: log_warn(2021,"unknown message %u", dh6msg->msg.type); } } return; } /* * On receiving DHC Request message */ int rly_request_rcv(struct rly_ifaddr *ria, struct msghdr *msg, int len) { struct sockaddr_in6 *src_addr = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; struct rly_ifaddr *ria2; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving Request message from %s", inet_ntop(AF_INET6, &src_addr->sin6_addr, 16, NULL)); #endif if ( !IN6_IS_ADDR_LINKLOCAL(&src_addr->sin6_addr) ) { log_warn(2022, "source address of Request not link-local"); return -1; } if ( memcmp(&src_addr->sin6_addr, get_request_llocal_addr(&dh6msg->req), sizeof(struct in6_addr)) ) { log_warn(2023, "lladdr in Request not the source address"); return -1; } ria2 = ria_get(get_request_agent_addr(&dh6msg->req)); if (ria2 == NULL || ria2->ria_ifi != ria->ria_ifi) { log_warn(2024, "invalid agent address in Request"); return -1; } if ( !dh6msg->req.Sbit ) { rly_reply_back(ria, msg, DH6_REPLY_POOR_FORM, 0, NULL); return -1; } rly_request_fwd(ria2, len, dh6msg); /* * TODO: * a subsequent ICMP from the server should get * the relay to send a reply with code 64 to the client. */ return 0; } /* * On receiving DHC Reply message */ int rly_reply_rcv(struct rly_ifaddr *ria, struct msghdr *msg, int len) { struct sockaddr_in6 *src_addr = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving Reply message from %s", inet_ntop(AF_INET6, &src_addr->sin6_addr, 16, NULL)); #endif if ( !dh6msg->rpl.Lbit ) { log_warn(2025, "Lbit == 0 in Reply"); return -1; } if ( !IN6_IS_ADDR_LINKLOCAL(get_reply_llocal_addr(&dh6msg->rpl)) ) { log_warn(2026, "lladdr in Reply not link-local"); return -1; } rly_request_fwd(ria, len, dh6msg); return 0; } void rly_run_unix_server( void * data ) { struct fd_list *p = (struct fd_list *)data, *fdp; int fd; struct sockaddr_un unix_addr; int unix_len = sizeof(unix_addr); for (;;) { fd = accept(p->fd, (struct sockaddr *)&unix_addr, &unix_len); if (fd < 0) { if ( errno!=EWOULDBLOCK ) log_sys(2027, "accept"); else return; /* no more pending connections */ } else { if ( (fdp=malloc(sizeof(struct fd_list))) == NULL ) log_sys(2028, "malloc"); init_fdp(fdp); fdp->fd = fd; fdp->data = fdp; fdp->function = rly_adm_msgrcv; add_fdp(fdp); } } } /* * to receive administration commands */ void rly_adm_msgrcv( void * data ) { struct fd_list *p = (struct fd_list *)data; ADM_MESSAGE msg; DH6_MESSAGE *dh6=(DH6_MESSAGE *)(&msg.un.dh6.msg); int len; for (;;) { len = recv(p->fd, (char*)&msg, MAX_MSG_LEN, 0); if ( len==0 ) return; else if (len < 0) { if (errno == EINTR) continue; else log_sys(2029, "recv"); } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving a message from dh6rc"); #endif if (msg.cmd == ADM_CMD_STOP ) { quit_flag = 1; break; } if (msg.cmd == ADM_DH6_MSG ) { switch ( dh6->msg.type ) { case DH6_SOLICIT: rly_solicit_adm(&msg, len); break; default: log_warn(1128,"unknown message %u", dh6->msg.type); } } } del_fdp(p); p->fd=-1; close(p->fd); free(p); } /* * On receiving a Solicit message from another process */ int rly_solicit_adm( ADM_MESSAGE *msg, int len ) { DH6_MESSAGE *dh6=(DH6_MESSAGE *)(&msg->un.dh6.msg); struct rly_ifaddr *ria = ria_get(&msg->un.dh6.laddr); if (ria == NULL) { log_warn(1129, "Invalid agent address"); return -1; } rly_solicit_unicast(ria, &msg->un.dh6.faddr, 0, NULL); return 0; } void rs_advertise_timeout( void * data ) { struct rly_server *rs = (struct rly_server *)data; struct rly_ifaddr *ria = relay_list.ria_head; if (ria == NULL) { log_warn(2032, "no relay address on list"); return; } rly_solicit_unicast(ria, &rs->rs_addr, 0, NULL); } int rly_solicit_send( struct in6_addr *rlyaddr, /* address on the receiving interface */ struct in6_addr *lladdr, /* link local address of the client */ int Cbit, /* copied from original message */ int extlen, void *ext) { struct sockaddr_in6 to6; u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg = (DH6_MESSAGE *)buf; int len; struct rly_ifaddr *ria; bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, dh6sin_server_group(), IPV6_ADDR_LEN); to6.sin6_port = htons(DH6_AGENT_PORT); bzero((char *)msg, MAX_MSG_LEN); msg->sol.type = DH6_SOLICIT; msg->sol.Cbit = Cbit; msg->sol.Lbit = 1; msg->sol.Abit = 1; msg->sol.Pbit = 0; set_solicit_llocal_addr(&msg->sol, lladdr); set_solicit_relay_addr(&msg->sol, rlyaddr); len = dh6_solicit_msg_len(&msg->sol); if ( extlen != 0 && ext != NULL ) { memcpy(buf+len, ext, extlen); len += extlen; } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Solicit len:%d, to: %s, port:%d", len, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif /* * The relay should not send sucha multicast solicitation * on the interface from which it received the solicitation * from the client. * See page 23, section 7, draft 8. */ for (ria = relay_list.ria_head; ria != NULL; ria = ria->next) { if ( !memcmp(&ria->ria_addr, rlyaddr, IPV6_ADDR_LEN) ) continue; _resend_solicit: if (sendto(ria->ria_sk.fd, msg, len, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != len) { if ( errno==EINTR ) goto _resend_solicit; if ( errno==EINVAL ) { log_info("Resending DHC Solicit"); goto _resend_solicit; } log_sys(2033, "sendto"); } } return 0; } int rly_solicit_unicast( struct rly_ifaddr *ria, /* relay address entry */ struct in6_addr *server, /* server address */ int extlen, void *ext) { struct sockaddr_in6 to6; u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg = (DH6_MESSAGE *)buf; int len; bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, server, IPV6_ADDR_LEN); to6.sin6_port = htons(DH6_AGENT_PORT); bzero((char *)msg, MAX_MSG_LEN); msg->sol.type = DH6_SOLICIT; msg->sol.Cbit = 0; msg->sol.Lbit = 0; msg->sol.Abit = 1; msg->sol.Pbit = 0; set_solicit_relay_addr(&msg->sol, &ria->ria_addr); len = dh6_solicit_msg_len(&msg->sol); if ( extlen != 0 && ext != NULL ) { memcpy(buf+len, ext, extlen); len += extlen; } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("unicasting DHC Solicit len:%d, to: %s, port:%d", len, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _reunicast_solicit: if (sendto(ria->ria_sk.fd, msg, len, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != len) { if ( errno==EINTR ) goto _reunicast_solicit; if ( errno==EINVAL ) goto _reunicast_solicit; log_sys(2034, "sendto"); } return 0; } int rly_advertise_send( struct rly_ifaddr *ria, /* relay address entry */ struct in6_addr *lladdr, /* the link local address of client */ int SvrCnt, /* number of server */ struct in6_addr *svraddr, /* a list of server addresses */ int extlen, /* length of extensions */ void *ext) /* extensions */ { struct sockaddr_in6 to6; u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg = (DH6_MESSAGE *)buf; int len; bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, lladdr, sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_CLIENT_PORT); bzero((char *)msg, MAX_MSG_LEN); msg->adv.type = DH6_ADVERTISE; msg->adv.lifetime = 0; /* unused */ msg->adv.Lbit = 0; msg->adv.Sbit = 0; msg->adv.SvrCnt = SvrCnt; memcpy(&msg->adv.AgtAddr, &ria->ria_addr, IPV6_ADDR_LEN); set_advertise_server_addr(&msg->adv, svraddr, SvrCnt); len = dh6_advertise_msg_len(&msg->adv); if ( extlen != 0 && ext != NULL ) { memcpy(buf+len, ext, extlen); len += extlen; } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Advertise len:%d, to: %s, port:%d", len, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _resend_advertise: if (sendto(ria->ria_sk.fd, msg, len, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != len) { if ( errno==EINTR ) goto _resend_advertise; if ( errno==EINVAL ) { log_info("Resending DHC Advertise"); goto _resend_advertise; } log_sys(2035, "fd(%d):sendto", ria->ria_sk.fd); } return 0; } int rly_advertise_fwd( struct rly_ifaddr *ria, /* relay entry */ int msglen, DH6_MESSAGE *msg) { struct sockaddr_in6 to6; if ( !msg->adv.Lbit ) return -1; bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, get_advertise_llocal_addr(&msg->adv), sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_CLIENT_PORT); #ifdef DH6_DEBUG if ( look_xmit() ) log_info("Forwarding Advertise len:%d, to:%s, port:%d",msglen, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _refwd_advertise: if (sendto(ria->ria_sk.fd, msg, msglen, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != msglen) { if ( errno==EINTR ) goto _refwd_advertise; if ( errno==EINVAL ) goto _refwd_advertise; log_sys(2036, "sendto"); } return 0; } int rly_request_fwd( struct rly_ifaddr *ria, /* relay entry */ int msglen, DH6_MESSAGE *msg) { struct sockaddr_in6 to6; if ( !msg->req.Sbit ) return -1; bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, get_request_server_addr(&msg->req), sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_AGENT_PORT); #ifdef DH6_DEBUG if ( look_xmit() ) log_info("Forwarding Request len:%d, to: %s, port:%d", msglen, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _resend_request: if (sendto(ria->ria_sk.fd, msg, msglen, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != msglen) { if ( errno==EINTR ) goto _resend_request; if ( errno==EINVAL ) { log_info("Resending DHC Request"); goto _resend_request; } log_sys(2037, "sendto"); } return 0; } int rly_reply_fwd( struct rly_ifaddr *ria, /* relay entry */ int msglen, DH6_MESSAGE *msg) { struct sockaddr_in6 to6; if ( !msg->rpl.Lbit ) return -1; bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, get_reply_llocal_addr(&msg->rpl), sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_CLIENT_PORT); #ifdef DH6_DEBUG if ( look_xmit() ) log_info("Forwarding DHC Reply len:%d, to:%s, port:%d",msglen, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _refwd_reply: if (sendto(ria->ria_sk.fd, msg, msglen, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != msglen) { if ( errno==EINTR ) goto _refwd_reply; if ( errno==EINVAL ) { log_info("Resending DHC Reply"); goto _refwd_reply; } log_sys(2038, "fd(%d):sendto", ria->ria_sk.fd); } return 0; } int rly_reply_back( struct rly_ifaddr *ria, /* relay entry */ struct msghdr *msg0, /* original message */ int code, /* error code */ int extlen, /* length of extensions */ void *ext) /* extensions */ { struct sockaddr_in6 *sdest = (struct sockaddr_in6 *)msg0->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg0->msg_iov[0].iov_base; struct sockaddr_in6 to6; u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg = (DH6_MESSAGE *)buf; int len; bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, &sdest->sin6_addr, IPV6_ADDR_LEN); to6.sin6_port = htons(DH6_CLIENT_PORT); bzero((char *)msg, MAX_MSG_LEN); msg->rpl.type = DH6_REPLY; msg->rpl.code = code; msg->rpl.id = dh6msg->req.id; msg->rpl.Lbit = 0; len = sizeof(struct dh6_reply); if ( extlen != 0 && ext != NULL ) { memcpy(reply_ext(&msg->rpl), ext, extlen); len += extlen; } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending back DHC Reply len:%d, to: %s, port:%d", len, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _resend_reply: if (sendto(ria->ria_sk.fd, msg, len, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != len) { if ( errno==EINTR ) goto _resend_reply; if ( errno==EINVAL ) goto _resend_reply; log_sys(2039, "fd(%d):sendto", ria->ria_sk.fd); } return 0; } switch ( dh6->msg.type ) { case DH6_SOLICIT: dhcpv6-1.0/dh6_rly.h010060000015740003721000000031540625233634200145140ustar00yunzhouip00000400000004/* * dh6_rly.h DHCPv6 Relay Data Structures * * Version: @(#)dh6_rly.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __DH6_RLY_H #define __DH6_RLY_H #define DH6RLY_CONF "dh6_relay.conf" #define RLY_CONF_PATH "/etc/" /* * Server address list */ struct rly_server { struct rly_server *next; struct rly_server *prev; IF_INFO *rs_ifi; /* interface information */ struct in6_addr rs_addr; /* server address */ struct u_timer rs_timer; u_int8_t rs_lifetime; }; /* * Relay Address list * including link-local address */ struct rly_ifaddr { struct rly_ifaddr *next; struct rly_ifaddr *prev; IF_INFO *ria_ifi; /* interface information */ struct in6_addr ria_addr; /* address (net order) */ struct fd_list ria_sk; /* UDP socket */ }; #endif /* __DH6_RLY_H */ dhcpv6-1.0/dh6_rlycmd.c010060000015740003721000000121720625233634200151730ustar00yunzhouip00000400000004/* * dh6_rlycmd.c DHCPv6 Relay Command * * Version: @(#)dh6_rlycmd.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "localdefs.h" #include "u_timer.h" #include "dispatch.h" #include "u_buf.h" #include "dh6.h" #include "ext6.h" #include "dh6_if.h" #include "dh6_rly.h" #include "dh6_adm.h" #include "sock.h" extern char *optarg; extern int optind, opterr, optopt; int debug = 0; /* * Generate an error message with the printf facility. */ void p_error (int err, const char *ctl, ...) { char buf[1000]; va_list list; va_start (list,ctl); vsprintf (buf,ctl,list); printf("error %d: %s\n", err, buf); } main( int argc, char * argv[] ) { int optval; char op; u_int8_t buf[MAX_MSG_LEN]; ADM_MESSAGE *msg=(ADM_MESSAGE *)buf; DH6_MESSAGE *dh6=(DH6_MESSAGE *)(&msg->un.dh6.msg); struct sockaddr_un serv_addr; int sockfd, servlen, msglen; if ( argc<2 ) cmd_usage(); while ((op = getopt(argc-1, argv+1, "d:D:")) != EOF) { switch (op) { #ifdef DH6_DEBUG case 'd': /* debug */ case 'D': /* debug */ debug = atoi(optarg); break; #endif default: } } if ( strcmp(argv[1],"start")==0 ) { char cmd[50]; sprintf(cmd, "%sdh6rd -d%d", DH6_SERV_PATH, debug); system(cmd); exit(0); } else if ( strcmp(argv[1],"restart")==0 ) { char cmd[50]; sprintf(cmd, "%s stop", argv[0]); system(cmd); sleep(1); sprintf(cmd, "%s start -d%d", argv[0], debug); system(cmd); exit(0); } else if ( strcmp(argv[1],"stop")!=0 && strcmp(argv[1],"solicit")!=0 ) cmd_usage(); bzero((char *) &serv_addr, sizeof(serv_addr)); serv_addr.sun_family = AF_UNIX; strcpy(serv_addr.sun_path, dh6rly_adm_server_name()); servlen = strlen(serv_addr.sun_path) + sizeof(serv_addr.sun_family) + 1; if ( (sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) p_error(2201, strerror(errno)); if (connect(sockfd, (struct sockaddr *) &serv_addr, servlen) < 0) p_error(2202, strerror(errno)); memset(buf, 0, MAX_MSG_LEN); if ( strcmp(argv[1],"stop")==0 ) { msg->cmd = ADM_CMD_STOP; msg->len = 0; msglen = 4; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } if ( strcmp(argv[1],"solicit")==0 ) { struct in6_addr addr; msg->cmd = ADM_DH6_MSG; msg->un.dh6.lport = DH6_AGENT_PORT; msg->un.dh6.fport = DH6_AGENT_PORT; dh6->sol.type = DH6_SOLICIT; dh6->sol.Cbit = 0; dh6->sol.Lbit = 0; dh6->sol.Abit = 1; dh6->sol.Pbit = 0; while ((op=getopt(argc-1,argv+1,"s:S:a:A:"))!=EOF) { switch (op) { case 's': case 'S': inet_pton(AF_INET6, optarg, &addr); memcpy(&msg->un.dh6.faddr, &addr, IPV6_ADDR_LEN); break; case 'a': case 'A': inet_pton(AF_INET6, optarg, &addr); memcpy(&msg->un.dh6.laddr, &addr, IPV6_ADDR_LEN); set_solicit_relay_addr(&dh6->sol, &addr); break; } } msg->len = ADM_DH6MSG_HDRLEN + dh6_solicit_msg_len(&dh6->sol); msglen = msg->len + 4; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } out: close(sockfd); exit(0); } cmd_usage( void ) { printf("usage: dh6rc start -d\n"); printf(" dh6rc restart -d\n"); printf(" dh6rc stop\n"); printf(" dh6rc solicit -s -a\n"); exit(1); } /* * send a message to server */ int cmd_sendto_serv( int sockfd, ADM_MESSAGE *msg, int msglen ) { if ( send(sockfd, msg, msglen, 0) != msglen) { p_error(2203, strerror(errno)); return -1; } return 0; } dhcpv6-1.0/dh6_server.conf010060000015740003721000000017650625233634200157200ustar00yunzhouip00000400000004# # dh6_server.conf DHCPv6 Server Configuration File # # Version: @(#)dh6_server.conf 1.0 Dec-8-96 # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # This program is distributed WITHOUT ANY WARRANTY and even the implied # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # # Many thanks to Jim Bound in Digital Equipment Corp. # Appreciate any further work on this release. # # Authors: Yunzhou Li (yunzhou@iol.unh.edu) # # # Maximal preferred and valid lifetimes MaxPreferLife 24 MaxValidLife 36 MulticastAddr "FF05::1:5" dhcpv6-1.0/dh6_svr.c010060000015740003721000001140710625233634200145140ustar00yunzhouip00000400000004/* * dh6_svr.c DHCPv6 Server Daemon * * Version: @(#)dh6_svr.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_if.h" #include "dh6_svr.h" #include "dh6_adm.h" #include "sock.h" #include "dh6_db.h" static void svr_run_unix_server( void * ); static void svr_adm_msgrcv( void * ); static void svr_dh6_msg_rcv( void * ); static void svr_dh6_multicast_rcv( void * ); extern void sc_xid_timeout( void * ); extern void db_check_timeout( void * ); struct fd_list multi_sock; /* multicast socket */ struct fd_list unix_sock; /* unix socket */ struct poll_list poll_unix; extern UNION_LIST ifi_table; UNION_LIST server_list; /* link local address not on this list */ struct u_timer db_check_timer = /* timer for checking/purging db */ { NULL, NULL, NULL, (void (*)(void *))db_check_timeout }; int debug = 0; int quit_flag = 0; int MaxPreferLife = DH6_MAX_PREFER_TIME; int MaxValidLife = DH6_MAX_VALID_TIME; struct in6_addr MulticastAddr; /* * There is a UDP socket for each server address; * There is only one multicast socket; */ void main( int argc, char *argv[] ) { struct ipv6_mreq mr6; int optval; char op; struct svr_ifaddr *sia; opterr = 0; while ((op = getopt(argc, argv, "d:D:")) != EOF) { switch (op) { #ifdef DH6_DEBUG case 'd': /* debug */ case 'D': /* debug */ debug = atoi(optarg); break; #endif default: } } if ( daemon_init() < 0 ) log_fatal(3001, "daemon init fail"); if (debug > 0) openlog ("", LOG_CONS, LOG_DAEMON); else openlog (argv[0], 0, LOG_DAEMON); u_free_list_init(); begin_timing(); init_ifi_table(); get_ifi_table(); #ifdef DH6_DEBUG if ( look_cache() ) { log_info("debug = %d", debug); print_ifi_table(); } #endif dh6_server_init(); svr_get_addr_table(); #ifdef DH6_DEBUG if ( look_cache() ) svr_print_addr_table(); #endif if ( (unix_sock.fd=open_unix_sock(dh6svr_adm_server_name())) < 0 ) log_fatal(3002, "open unix socket fail"); init_poll(&poll_unix); poll_unix.data = &unix_sock; poll_unix.function = svr_run_unix_server; add_poll(&poll_unix); if ( (multi_sock.fd=svr_udp6_socket(NULL)) < 0) log_fatal(3003, "open UDP6 socket fail"); #ifdef IPV6_TXINFO_WORK optval = 1; if (setsockopt(multi_sock.fd, IPPROTO_IPV6, IPV6_TXINFO, (char *)&optval, sizeof(optval)) < 0) log_fatal(3004, "IPV6_TXINFO fail"); #endif optval = 1; if (setsockopt(multi_sock.fd, IPPROTO_IPV6, IPV6_RXINFO, (char *)&optval, sizeof(optval)) < 0) log_fatal(3005, "IPV6_RXINFO fail"); init_fdp(&multi_sock); multi_sock.data = &multi_sock; multi_sock.function = svr_dh6_multicast_rcv; add_fdp(&multi_sock); /* open a socket for each server address */ for (sia = server_list.sia_head; sia != NULL; sia = sia->next) { if ( (sia->sia_sk.fd=svr_udp6_socket(&sia->sia_addr)) < 0) log_fatal(3006, "open UDP6 socket fail"); memcpy(&mr6.ipv6mr_interface, &sia->sia_addr, sizeof(struct in6_addr)); /* join server multicast group */ memcpy(&mr6.ipv6mr_multiaddr, dh6sin_server_group(), sizeof(struct in6_addr)); if (setsockopt(sia->sia_sk.fd, IPPROTO_IPV6, IP_ADD_MEMBERSHIP, (caddr_t)&mr6, sizeof(mr6)) < 0) log_fatal(3007, "server IP_ADD_MEMBERSHIP fail"); /* join agent multicast group */ memcpy(&mr6.ipv6mr_multiaddr, dh6sin_agent_group(), sizeof(struct in6_addr)); if (setsockopt(sia->sia_sk.fd, IPPROTO_IPV6, IP_ADD_MEMBERSHIP, (caddr_t)&mr6, sizeof(mr6)) < 0) log_fatal(3008, "agent IP_ADD_MEMBERSHIP fail"); if (setsockopt(sia->sia_sk.fd, IPPROTO_IPV6, IP_MULTICAST_IF, (char *)&sia->sia_addr, IPV6_ADDR_LEN) < 0) log_fatal(3009, "IP_MULTICAST_IF fail"); init_fdp(&sia->sia_sk); sia->sia_sk.data = sia; sia->sia_sk.function = svr_dh6_msg_rcv; add_fdp(&sia->sia_sk); } read_dh6_server_conf(); /* read from "dh6_server.conf" */ /* * start timer to check db once per SVR_DB_CHECK_INTERVAL */ init_timer(&db_check_timer); db_check_timer.data = NULL; db_check_timer.function = (void (*)(void *))db_check_timeout; start_timer(&db_check_timer, SVR_DB_CHECK_INTERVAL); for (;;) { dispatch(); if ( quit_flag ) break; } end_timing(); del_poll(&poll_unix); close_unix_sock(unix_sock.fd, dh6svr_adm_server_name()); del_fdp(&multi_sock); close(multi_sock.fd); for (sia = server_list.sia_head; sia != NULL; sia = sia->next) { if (sia->sia_sk.fd > 0) { del_fdp(&sia->sia_sk); close(sia->sia_sk.fd); } } stop_timer(&db_check_timer); #ifdef DH6_DEBUG if ( look_xmit() ) log_info("exit from %s", argv[0]); #endif closelog(); exit(0); } struct svr_client * sc_create( void ) { struct svr_client *sc; if ( (sc=u_alloc_node()) == NULL ) return NULL; sc->sc_sia = NULL; sc->sc_state = SC_STATE_NONE; init_timer(&sc->sc_xmit_timer); sc->sc_xmit_timer.data = (void *)sc; sc->sc_xmit_timer.function = u_ignore; sc->sc_xmit_timeout = 0; init_timer(&sc->sc_dns_timer); sc->sc_dns_timer.data = (void *)sc; sc->sc_dns_timer.function = u_ignore; return sc; } inline void sc_destroy( struct svr_client *sc ) { stop_timer(&sc->sc_xmit_timer); stop_timer(&sc->sc_dns_timer); sc->sc_xmit_timeout = 0; u_free_node(sc); } struct svr_client * sc_get( struct svr_ifaddr *sia, struct in6_addr *ll_addr, struct in6_addr *rly_addr) { struct svr_client *sc; if (sia == NULL) return NULL; for (sc = sia->sia_clilist.sc_head; sc != NULL; sc = sc->next) { if ( !memcmp(&sc->sc_lladdr, ll_addr, IPV6_ADDR_LEN) && !memcmp(&sc->sc_rlyaddr,rly_addr,IPV6_ADDR_LEN) ) return sc; } return NULL; } struct svr_ifaddr * sia_create( void ) { struct svr_ifaddr *sia; if ( (sia=u_alloc_node()) == NULL ) return NULL; sia->sia_ifi = NULL; sia->sia_clilist.sc.head = NULL; sia->sia_clilist.sc.tail = NULL; sia->sia_sk.fd = -1; sia->sia_lifetime = SERVER_DEFAULT_LIFETIME; /* * Server should periodically multicast Advertise messages */ return sia; } inline void sia_destroy( struct svr_ifaddr *sia ) { if (sia->sia_sk.fd > 0) { del_fdp(&sia->sia_sk); close(sia->sia_sk.fd); } u_free_node(sia); } struct svr_ifaddr * sia_get(struct in6_addr *addr) { struct svr_ifaddr *sia; for (sia = server_list.sia_head; sia != NULL; sia = sia->next) { if ( !memcmp(&sia->sia_addr, addr, IPV6_ADDR_LEN) ) return sia; } return NULL; } int dh6_server_init( void ) { server_list.chain.head = NULL; server_list.chain.tail = NULL; memset(&MulticastAddr, 0, IPV6_ADDR_LEN); } int svr_get_addr_table( void ) { u_char buf[8192]; u_char *buf_end; struct ifconf ifc; struct ifreq *ifr; struct if_info *ifi; struct svr_ifaddr *sia; struct sockaddr_in6 *sin6; int s; if ((s=socket(AF_INET6, SOCK_DGRAM, 0)) < 0) log_sys(3010, "socket"); ifc.ifc_len = sizeof(buf); ifc.ifc_buf = (char *)buf; if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) log_fatal(3011,"SIOCGIFCONF failed"); buf_end = buf + ifc.ifc_len; ifr = ifc.ifc_req; while ((u_char *)ifr < buf_end) { sin6 = (struct sockaddr_in6 *)&ifr->ifr_addr; if ( ifr->ifr_addr.sa_family == AF_INET6 && !IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ) { if ( (sia = u_alloc_node()) == NULL ) return -1; memset(sia, 0, sizeof(struct svr_ifaddr)); sia->sia_ifi = seek_ifi_byname(ifr->ifr_name, strlen(ifr->ifr_name)); memcpy(&sia->sia_addr, &sin6->sin6_addr, sizeof(struct in6_addr)); sia->sia_lifetime = SERVER_DEFAULT_LIFETIME; sia->sia_clilist.sc.head = NULL; sia->sia_clilist.sc.tail = NULL; u_queue_tail(&server_list, sia); } ifr = (struct ifreq *)((char *)ifr + sizeof(ifr->ifr_name) + (sizeof(ifr->ifr_addr) > ifr->ifr_addr.sa_len ? sizeof(ifr->ifr_addr) : ifr->ifr_addr.sa_len )); } close(s); return 0; } #ifdef DH6_DEBUG int svr_print_addr_table( void ) { struct svr_ifaddr *sia; int n = 1; log_info("Server table:"); for (sia = server_list.sia_head; sia != NULL; sia = sia->next) { log_info(" addr: %s, if: %s, lifetime: %d", inet_ntop(AF_INET6,&sia->sia_addr,16,NULL), ifi_ifname(sia->sia_ifi), sia->sia_lifetime); } return 0; } #endif struct svr_ifaddr * svr_get_server_byifname(char *name, int len) { struct svr_ifaddr *sia; for (sia = server_list.sia_head; sia != NULL; sia = sia->next) { if ( !memcmp(ifi_ifname(sia->sia_ifi), name, len) ) return sia; } return NULL; } struct svr_ifaddr * svr_get_server_byifindex(int ifindex) { struct svr_ifaddr *sia; for (sia = server_list.sia_head; sia != NULL; sia = sia->next) { if (ifi_ifindex(sia->sia_ifi) == ifindex) return sia; } return NULL; } /* * Check the server database and purge record if necessarily */ static int dh6db_check_purge( void ) { DB *db, *db2; DBT key, rec; struct svr_record *p; u_int32_t prefer, valid; if ( (db=dh6db_open(DH6_SVR_INUSE)) == NULL) log_sys(3012, "dbopen error"); if ( (db2=dh6db_open(DH6_SVR_INVAL)) == NULL) log_sys(3013, "dbopen error"); memset(&key, 0, sizeof(key)); key.size = KPREFIX_LEN; key.data = &key_prefix; db->seq(db, &key, &rec, R_CURSOR); do { if (rec.size < sizeof(struct svr_record)) break; #ifdef DH6_DEBUG if ( look_db_more() ) log_info("Got a next record (size:%d)in purging", rec.size); #endif /* remove from DH6_SVR_INUSE and save to DH6_SVR_INVAL */ p = (struct svr_record *)rec.data; dh6db_copy(&prefer, &p->prefer_life, 4); dh6db_copy(&valid, &p->valid_life, 4); if (valid == 0) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("deleting a record"); #endif db->del(db, &key, R_CURSOR); db->sync(db, R_RECNOSYNC); p->state = SC_STATE_DELETE; db2->put(db2, &key, &rec, R_NOOVERWRITE); db2->sync(db2, R_RECNOSYNC); } /* change the state */ else if (prefer == 0) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("changing the state of a record"); #endif p->state = SC_STATE_VALID; db->put(db, &key, &rec, R_NOOVERWRITE); db->sync(db, R_RECNOSYNC); } /* * TODO: Never delete or change the state of * permanent client records. */ } while (db->seq(db, &key, &rec, R_NEXT) == 0); dh6db_close(db2); dh6db_close(db); return 0; } /* * to receive DHCPv6 messages */ static void svr_dh6_multicast_rcv( void * data ) { struct fd_list *sock = (struct fd_list *)data; u_int8_t buf[MAX_MSG_LEN]; u_int8_t ctrldata[64]; for (;;) { struct iovec aiov[1]; struct msghdr msg; struct cmsghdr *cmsg = (struct cmsghdr *)ctrldata; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)buf; struct sockaddr_in6 sin6; int len; msg.msg_name = (caddr_t)&sin6; msg.msg_namelen = sizeof(struct sockaddr_in6) ; msg.msg_iov = aiov; msg.msg_iovlen = 1; aiov[0].iov_base = buf; aiov[0].iov_len = MAX_MSG_LEN; msg.msg_control = ctrldata; msg.msg_controllen = sizeof(ctrldata); msg.msg_flags = 0; len = recvmsg(sock->fd, &msg, 0); /* * It is very possible for signal SIGCHLD to interrupt this * slow system call recvfrom */ __ugly: if (len == 0) return; else if (len < 0) { if (errno == EINTR) goto __ugly; if (errno == EWOULDBLOCK) return; /* no more messages */ log_sys(3014, "recvfrom"); } switch ( dh6msg->msg.type ) { case DH6_SOLICIT: svr_solicit_rcv(&msg, len); break; default: log_warn(3015,"unknown message %u", dh6msg->msg.type); } } return; } /* * On receiving DHC Solicit message */ int svr_solicit_rcv(struct msghdr *msg, int len) { struct sockaddr_in6 *src_addr = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; struct in6_pktinfo *pktinfo; struct svr_ifaddr *sia; int extlen = 0; void *ext = NULL; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving Solicit message from %s", inet_ntop(AF_INET6, &src_addr->sin6_addr, 16, NULL)); #endif #ifdef TODO if ( dest_is_server_group(&dh6msg->sol) && IN6_IS_ADDR_LINKLOCAL(&src_addr->sin6_addr) ) { log_warn(3016, "src is link-local but dst is server multicast"); return -1; } #endif if ( !memcmp(&src_addr->sin6_addr, dh6sin_server_group(), sizeof(struct in6_addr)) && IN6_IS_ADDR_LINKLOCAL(&src_addr->sin6_addr) ) { log_warn(3017, "src addr is link-local but from a relay"); return -1; } if ( dh6msg->sol.Lbit && !dh6msg->sol.Abit ){ log_warn(3018, "malfunctionaing relay agent"); return -1; } if (len != sizeof(struct dh6_solicit) + dh6msg->sol.Lbit * IPV6_ADDR_LEN + dh6msg->sol.Abit * IPV6_ADDR_LEN ) { log_warn(3019, "Solicit message length incorrect"); return -1; } if ((pktinfo=cmsg_get(msg, IPPROTO_IPV6, IPV6_RXINFO)) == NULL) { log_warn(3020, "IPV6_RXINFO not found"); return -1; } if ((sia=svr_get_server_byifindex(pktinfo->ipi6_ifindex)) == NULL) { log_warn(3021, "server address entry cannot be located"); return -1; } #ifdef TODO svr_alloc_advertise_ext(&ext, &extlen); #endif if ( dh6msg->sol.Lbit ) svr_advertise_send(sia, get_solicit_llocal_addr(&dh6msg->sol), get_solicit_relay_addr(&dh6msg->sol), extlen, ext); else svr_advertise_send(sia, &src_addr->sin6_addr, NULL,extlen,ext); #ifdef TODO free(ext); #endif /* * Cleaning up the database for the specific client. */ if ( dh6msg->sol.Cbit ) { DB *db, *db2; DBT key, rec; struct svr_record *p; if ( (db=dh6db_open(DH6_SVR_INUSE)) == NULL) log_sys(3022, "dbopen error"); if ( (db2=dh6db_open(DH6_SVR_INVAL)) == NULL) log_sys(3023, "dbopen error"); memset(&key, 0, sizeof(key)); key.size = KPREFIX_LEN; key.data = &key_prefix; db->seq(db, &key, &rec, R_CURSOR); do { if (rec.size < sizeof(struct svr_record)) break; p = (struct svr_record *)rec.data; if ( !memcmp(get_solicit_llocal_addr(&dh6msg->sol), &p->lladdr, IPV6_ADDR_LEN) ) { db->del(db, &key, R_CURSOR); db->sync(db, R_RECNOSYNC); db2->put(db2, &key, &rec, R_NOOVERWRITE); db2->sync(db2, R_RECNOSYNC); } } while (db->seq(db, &key, &rec, R_NEXT) == 0); dh6db_close(db2); dh6db_close(db); } #ifdef TODO look_into_other_extensions(&dh6msg->sol); #endif return 0; } /* * to receive DHCPv6 messages */ static void svr_dh6_msg_rcv( void * data ) { struct svr_ifaddr *sia = (struct svr_ifaddr *)data; u_int8_t buf[MAX_MSG_LEN]; u_int8_t ctrldata[64]; for (;;) { struct iovec aiov[1]; struct msghdr msg; struct cmsghdr *cmsg = (struct cmsghdr *)ctrldata; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)buf; struct sockaddr_in6 sin6; int len; msg.msg_name = (caddr_t)&sin6; msg.msg_namelen = sizeof(struct sockaddr_in6) ; msg.msg_iov = aiov; msg.msg_iovlen = 1; aiov[0].iov_base = buf; aiov[0].iov_len = MAX_MSG_LEN; msg.msg_control = ctrldata; msg.msg_controllen = sizeof(ctrldata); msg.msg_flags = 0; len = recvmsg(sia->sia_sk.fd, &msg, 0); /* * It is very possible for signal SIGCHLD to interrupt this * slow system call recvfrom */ __ugly2: if (len == 0) return; else if (len < 0) { if (errno == EINTR) goto __ugly2; if (errno == EWOULDBLOCK) return; /* no more messages */ log_sys(3024, "recvfrom"); } switch ( dh6msg->msg.type ) { case DH6_REQUEST: svr_request_rcv(sia, &msg, len); break; case DH6_RELEASE: svr_release_rcv(sia, &msg, len); break; default: log_warn(3025,"unknown message %u", dh6msg->msg.type); } } return; } /* * On receiving DHC Request message */ int svr_request_rcv(struct svr_ifaddr *sia, struct msghdr *msg, int len) { struct sockaddr_in6 *src_addr = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; struct svr_client *sc; struct ext6_addr *addrext; DB *db; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving Request message from %s", inet_ntop(AF_INET6, &src_addr->sin6_addr, 16, NULL)); #endif if (len < dh6_request_msg_len(&dh6msg->req)) { log_warn(3026, "Request msg is not so long as expected"); svr_reply_send(sia,msg,DH6_REPLY_POOR_FORM,0,NULL); return -1; } if ( !IN6_IS_ADDR_LINKLOCAL(get_request_llocal_addr(&dh6msg->req)) ) { log_warn(3027, "lladdr field in Request not link-local"); return -1; } if ( IN6_IS_MULTICAST(&sia->sia_addr) ) { log_warn(3028, "Request is destined to a multicast address"); return -1; } if ( dh6msg->req.Sbit && memcmp(&sia->sia_addr, get_request_server_addr(&dh6msg->req), IPV6_ADDR_LEN) ) { log_warn(3029, "dest_addr not the server addr in Request"); return -1; } /* * Producing error code 20 is doubtful because: * A client may send a Request message for additional * configuration parameters; the client may send a * Request to verify the existing parameters in the server; * the client may send request to extend its lifetime. */ dh6db_load_sc(sia, get_request_llocal_addr(&dh6msg->req), get_request_agent_addr(&dh6msg->req)); sc = sc_get(sia, get_request_llocal_addr(&dh6msg->req), get_request_agent_addr(&dh6msg->req)); addrext = (struct ext6_addr *)ext6_get(EXT6_ADDR, request_ext(&dh6msg->req), len - dh6_request_msg_len(&dh6msg->req)); /* * Cleaning up the database in required for client's request * TODO: other parameters needs to be cleaned by checking * with other extensions. * * Probably the idea here is not good because the server * delocate resources any way and then allocate the same * resources from DH6_SVR_INVAL. Any FIXES would be * greatly appreciated. */ if (sc != NULL && dh6msg->req.Cbit && (addrext == NULL || !addrext->Cbit || memcmp(&sc->sc_cliaddr,get_ext6_addr_client_addr,IPV6_ADDR_LEN))) { DB *db, *db2; if ( (db=dh6db_open(DH6_SVR_INUSE)) == NULL) log_sys(3030, "dbopen error"); if ( (db2=dh6db_open(DH6_SVR_INVAL)) == NULL) log_sys(3031, "dbopen error"); if (dh6db_locate(db,sc) == 0) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("found the record in cleaning"); #endif dh6db_del(db, sc, R_CURSOR); dh6db_sync(db, R_RECNOSYNC); sc->sc_state = SC_STATE_DELETE; dh6db_put(db2, sc, R_NOOVERWRITE); dh6db_sync(db2,R_RECNOSYNC); } dh6db_close(db2); dh6db_close(db); u_unlink(&sia->sia_clilist, sc); sc_destroy(sc); sc = NULL; if (addrext == NULL) /* just to release all ???? */ return 0; } /* * Look into address extension and send replies if necessary. * What should I do if there is more than one address extension? */ svr_request_addrext_rcv(sia, &sc, msg, addrext); /* * TODO: Should I look into other extensions and * additionally send other replies? * * Accept some extensions but may reject others. * See page 22, draft 08. */ return 0; } /* * Handle an Address extension and send DHC Reply if required */ int svr_request_addrext_rcv(struct svr_ifaddr *sia, struct svr_client **sc, struct msghdr *msg, struct ext6_addr *addrext) { struct sockaddr_in6 *src_addr = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; void *ext = NULL; int extlen = 0; DB *db; /* * Here we are sure that there is no record in DH6_SVR_INUSE. */ if ( *sc == NULL ) { u_int32_t prefer, valid; if ( (*sc=sc_create()) == NULL ) { svr_reply_send(sia,msg,DH6_REPLY_RSRC_UNAVAIL,0,NULL); return -1; } u_queue_head(&sia->sia_clilist, *sc); (*sc)->sc_sia = sia; memcpy(&(*sc)->sc_lladdr, get_request_llocal_addr(&dh6msg->req), sizeof(struct in6_addr)); memcpy(&(*sc)->sc_rlyaddr, get_request_agent_addr(&dh6msg->req), sizeof(struct in6_addr)); if ( !dh6_any_idle_dh6addr() ) { svr_reply_send(sia,msg,DH6_REPLY_RSRC_UNAVAIL,0,NULL); u_unlink(&sia->sia_clilist,*sc); sc_destroy(*sc); return -1; } if (addrext && addrext->Cbit) { memcpy(&(*sc)->sc_cliaddr, get_ext6_addr_client_addr(addrext), sizeof(struct in6_addr)); if ( dh6_get_requested_dh6addr(*sc) ) ; else if ( addrext->Qbit ) { svr_reply_send(sia,msg, DH6_REPLY_UNABLE_EXT_PARA,0,NULL); u_unlink(&sia->sia_clilist,*sc); sc_destroy(*sc); return -1; } else dh6_get_idle_dh6addr(*sc); } else dh6_get_idle_dh6addr(*sc); (*sc)->sc_id = ntohs(dh6msg->req.id); if ( addrext ) { prefer = get_ext6_addr_prefer_lifetime(addrext); if (prefer > MaxPreferLife) prefer = DH6_DEFAULT_PREFER_TIME; valid = get_ext6_addr_valid_lifetime(addrext); if (valid > MaxValidLife) valid = DH6_DEFAULT_VALID_TIME; } else { prefer = DH6_DEFAULT_PREFER_TIME; valid = DH6_DEFAULT_VALID_TIME; } #ifdef TODO if (is_specific_client(get_request_llocal_addr(&dh6msg->req))) { prefer = ~0; valid = ~0; } #endif ext = SVR_APPEND_ADDR_EXT6(ext, &extlen, &(*sc)->sc_cliaddr, (*sc)->sc_prfsize, prefer, valid); /* no duplication detection required ? */ ext = svr_append_multicast_ext6(ext, &extlen, &MulticastAddr); svr_reply_send(sia,msg,DH6_REPLY_SUCCESS,extlen,ext); free(ext); /* * TODO: * If the client requests DNS updates, and sets the 'Q' bit, * the server MUST NOT issue the DHCP Reply until after * receiving positive indication that the DNS update has * indeed been informed. (page 7, ext6) */ (*sc)->sc_xmit_timer.function = (void (*)(void *))sc_xid_timeout; start_timer(&(*sc)->sc_xmit_timer, XID_TIMEOUT); (*sc)->sc_xmit_timeout = XID_TIMEOUT; (*sc)->sc_state = SC_STATE_TEMP; if ( (db=dh6db_open(DH6_SVR_INUSE)) < 0) log_sys(3032, "dbopen"); dh6db_put(db, *sc, R_NOOVERWRITE); dh6db_sync(db); dh6db_close(db); } /* * This client previously made a request. * and thus there must be a record in DH6_SVR_INUSE. */ else { u_int32_t prefer, valid; /* * Go the same way whether or not it is a retransmission: * ( ntohs(dh6msg->req.id) == (*sc)->sc_id ) */ (*sc)->sc_id = ntohs(dh6msg->req.id); if ( addrext ) { prefer = get_ext6_addr_prefer_lifetime(addrext); if (prefer > MaxPreferLife) prefer = DH6_DEFAULT_PREFER_TIME; valid = get_ext6_addr_valid_lifetime(addrext); if (valid > MaxValidLife) valid = DH6_DEFAULT_VALID_TIME; } else { prefer = DH6_DEFAULT_PREFER_TIME; valid = DH6_DEFAULT_VALID_TIME; } #ifdef TODO if (is_specific_client(get_request_llocal_addr(&dh6msg->req))) { prefer = ~0; valid = ~0; } #endif ext = SVR_APPEND_ADDR_EXT6(ext, &extlen, &(*sc)->sc_cliaddr, (*sc)->sc_prfsize, prefer, valid); /* no duplication detection required ? */ svr_reply_send(sia,msg,DH6_REPLY_SUCCESS,extlen,ext); free(ext); (*sc)->sc_xmit_timer.function = (void (*)(void *))sc_xid_timeout; start_timer(&(*sc)->sc_xmit_timer, XID_TIMEOUT); (*sc)->sc_xmit_timeout = XID_TIMEOUT; (*sc)->sc_state = SC_STATE_TEMP; if ( (db=dh6db_open(DH6_SVR_INUSE)) < 0) log_sys(3033, "dbopen"); if (dh6db_locate(db, *sc) == 0) dh6db_put(db, *sc, R_CURSOR); dh6db_sync(db); dh6db_close(db); } return 0; } /* * On receiving DHC Release message */ int svr_release_rcv(struct svr_ifaddr *sia, struct msghdr *msg, int len) { struct sockaddr_in6 *src_addr = (struct sockaddr_in6 *)msg->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg->msg_iov[0].iov_base; struct svr_client *sc; struct ext6_addr *addrext; DB *db, *db2; int extlen; #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving Release message from %s", inet_ntop(AF_INET6, &src_addr->sin6_addr, 16, NULL)); #endif if ( !IN6_IS_ADDR_LINKLOCAL(&dh6msg->rel.lladdr) ) { log_warn(3034, "lladdr in Release not link-local"); return -1; } addrext = (struct ext6_addr *)ext6_get(EXT6_ADDR, dh6msg->rel.ext, len - dh6_release_msg_len(&dh6msg->rel)); if ( addrext != NULL && addrext->Cbit && dh6msg->rel.Dbit && memcmp(&src_addr->sin6_addr, get_ext6_addr_client_addr(addrext), IPV6_ADDR_LEN) ) { svr_reply_send(sia,msg,DH6_REPLY_INVAL_REL_SRC,0,NULL); log_warn(3035, "Reply directly sent but source addr mismatch"); return -1; /* page 19, draft 08 */ } #ifdef TODO if (addrext == NULL && there_are_other_extensions(&dh6msg->rel) ) { void *ext2 = NULL; int len2 = 0; for (;;) { ext2 = server_cannot_process(&dh6msg->rel,&len2); if (ext2 == NULL || len2 == 0) break; svr_reply_send(sia,msg,relevant_error,len2,ext2); } for (;;) { ext2 = server_can_process(&dh6msg->rel,&len2); if (ext2 == NULL || len2 == 0) return 0; svr_reply_send(sia,msg,DH6_REPLY_SUCCESS,len2,ext2); release_particular_parameters(sia,msg); svr_purge_db(sia, msg); } } #endif extlen = (addrext) ? ext6_addr_len(addrext) : 0; if ( addrext ) { set_ext6_addr_prefer_lifetime(addrext, 0); set_ext6_addr_valid_lifetime(addrext, 0); } dh6db_load_sc(sia, &dh6msg->rel.lladdr, &dh6msg->rel.AgtAddr); sc = sc_get(sia, &dh6msg->rel.lladdr, &dh6msg->rel.AgtAddr); if ( sc == NULL ) { svr_reply_send(sia,msg,DH6_REPLY_CLI_REC_UNAVAIL, extlen, addrext); return -1; } svr_reply_send(sia, msg, DH6_REPLY_SUCCESS, extlen, addrext); if ( (db=dh6db_open(DH6_SVR_INUSE)) == NULL) log_sys(3036, "dbopen error"); if ( (db2=dh6db_open(DH6_SVR_INVAL)) == NULL) log_sys(3037, "dbopen error"); if (dh6db_locate(db,sc) == 0) { dh6db_del(db, sc, R_CURSOR); dh6db_sync(db, R_RECNOSYNC); sc->sc_state = SC_STATE_DELETE; dh6db_put(db2, sc, R_NOOVERWRITE); dh6db_sync(db2,R_RECNOSYNC); } dh6db_close(db2); dh6db_close(db); return 0; } static void svr_run_unix_server( void * data ) { struct fd_list *p = (struct fd_list *)data, *fdp; int fd; struct sockaddr_un unix_addr; int unix_len = sizeof(unix_addr); for (;;) { fd = accept(p->fd, (struct sockaddr *)&unix_addr, &unix_len); if (fd < 0) { if ( errno!=EWOULDBLOCK ) log_sys(3038, "accept"); else return; /* no more pending connections */ } else { if ( (fdp=malloc(sizeof(struct fd_list))) == NULL ) log_sys(3039, "malloc"); init_fdp(fdp); fdp->fd = fd; fdp->data = fdp; fdp->function = svr_adm_msgrcv; add_fdp(fdp); } } } /* * to receive administration commands */ static void svr_adm_msgrcv( void * data ) { struct fd_list *p = (struct fd_list *)data; ADM_MESSAGE msg; DH6_MESSAGE *dh6=(DH6_MESSAGE *)(&msg.un.dh6.msg); int len; for (;;) { len = recv(p->fd, (char*)&msg, MAX_MSG_LEN, 0); if ( len==0 ) return; else if (len < 0) { if (errno == EINTR) continue; else log_sys(3040, "recv"); } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving a message from dh6sc"); #endif if (msg.cmd == ADM_CMD_STOP ) { quit_flag = 1; break; } if (msg.cmd == ADM_SHOW_DB ) { svr_dbshow_adm(msg, len); continue; } if (msg.cmd == ADM_DH6_MSG ) { switch ( dh6->msg.type ) { case DH6_RECONFIGURE: svr_reconfigure_adm(&msg, len); break; default: log_warn(1128,"unknown message %u", dh6->msg.type); } } } del_fdp(p); p->fd=-1; close(p->fd); free(p); } /* * On receiving a Reconfigure message from another process */ int svr_reconfigure_adm( ADM_MESSAGE *msg, int len ) { DH6_MESSAGE *dh6=(DH6_MESSAGE *)(&msg->un.dh6.msg); struct svr_ifaddr *sia; struct sockaddr_in6 to6; sia = sia_get(&msg->un.dh6.laddr); if ( sia == NULL ) { log_warn(3129, "The server entry not found"); return -1; } bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, &msg->un.dh6.faddr, sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_CLIENT_PORT); #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Reconfigure len:%d, to: %s, port:%d", msg->len-ADM_DH6MSG_HDRLEN, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _resend_reconfigure2: if (sendto(sia->sia_sk.fd, dh6, msg->len-ADM_DH6MSG_HDRLEN, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != msg->len-ADM_DH6MSG_HDRLEN) { if ( errno==EINTR ) goto _resend_reconfigure2; if ( errno==EINVAL ) goto _resend_reconfigure2; log_sys_warn(3046, "fd(%d):sendto", sia->sia_sk.fd); } return 0; } /* * When the XID_TIMEOUT expires */ void sc_xid_timeout( void * data ) { struct svr_client *sc = (struct svr_client *)data; DB *db; sc->sc_xmit_timeout = 0; sc->sc_state = SC_STATE_PREFER; if ( (db=dh6db_open(DH6_SVR_INUSE)) < 0) log_sys(3043, "dbopen"); if (dh6db_locate(db, sc) == 0) dh6db_put(db, sc, R_CURSOR); dh6db_sync(db); dh6db_close(db); } /* * When DB check timer expires */ void db_check_timeout( void * data ) { dh6db_check_purge(); start_timer(&db_check_timer,SVR_DB_CHECK_INTERVAL); } int svr_advertise_send( struct svr_ifaddr *sia, /* server address entry */ struct in6_addr *lladdr, /* the link local address of client */ struct in6_addr *agent, /* relay agent address */ int extlen, /* length of extensions */ void *ext) /* extensions */ { struct sockaddr_in6 to6; u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg = (DH6_MESSAGE *)buf; int len; bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; if (agent != NULL) { memcpy(&to6.sin6_addr, agent, sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_AGENT_PORT); } else { memcpy(&to6.sin6_addr, lladdr, sizeof(struct in6_addr)); to6.sin6_port = htons(DH6_CLIENT_PORT); } bzero((char *)msg, MAX_MSG_LEN); msg->adv.type = DH6_ADVERTISE; if ( IN6_IS_ADDR_LINKLOCAL(&to6.sin6_addr) ) msg->adv.lifetime = 0; else msg->adv.lifetime = sia->sia_lifetime; if (agent == NULL) { msg->adv.Lbit = 0; msg->adv.Sbit = 1; msg->adv.SvrCnt = 0; memcpy(&msg->adv.AgtAddr, &sia->sia_addr, IPV6_ADDR_LEN); len = sizeof(struct dh6_advertise); } else { msg->adv.Lbit = 1; msg->adv.Sbit = 0; /* * When can we give more server addresses? */ msg->adv.SvrCnt = 1; memcpy(&msg->adv.AgtAddr, agent, IPV6_ADDR_LEN); set_advertise_llocal_addr(&msg->adv, lladdr); set_advertise_server_addr(&msg->adv, &sia->sia_addr, 1); len = sizeof(struct dh6_advertise) + (msg->adv.SvrCnt+1)*IPV6_ADDR_LEN; } if ( extlen != 0 && ext != NULL ) { memcpy(advertise_ext(&msg->adv), ext, extlen); len += extlen; } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Advertise len:%d, to: %s, port:%d", len, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); if ( look_xmit_more() ) log_info("where agent = %s", inet_ntop(AF_INET6, &msg->adv.AgtAddr, 16, NULL)); #endif _resend_advertise: if (sendto(sia->sia_sk.fd, msg, len, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != len) { if ( errno==EINTR ) goto _resend_advertise; if ( errno==EINVAL ) { log_info("Resending DHC Advertise"); goto _resend_advertise; } log_warn(3044, "sendto error %d: %s", errno, strerror(errno)); } return 0; } int svr_reply_send( struct svr_ifaddr *sia, /* server entry */ struct msghdr *msg0, /* original message */ int code, /* error code */ int extlen, /* length of extensions */ void *ext) /* extensions */ { struct sockaddr_in6 *sdest = (struct sockaddr_in6 *)msg0->msg_name; DH6_MESSAGE *dh6msg = (DH6_MESSAGE *)msg0->msg_iov[0].iov_base; struct sockaddr_in6 to6; u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg = (DH6_MESSAGE *)buf; int len; struct in6_addr *lladdr, *agent; if (dh6msg->req.type == DH6_REQUEST) { lladdr = get_request_llocal_addr(&dh6msg->req); agent = get_request_agent_addr(&dh6msg->req); } else { lladdr = &dh6msg->rel.lladdr; agent = &dh6msg->rel.AgtAddr; } bzero((char *)&to6, sizeof(to6)); bzero((char *)msg, MAX_MSG_LEN); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, &sdest->sin6_addr, IPV6_ADDR_LEN); msg->rpl.type = DH6_REPLY; msg->rpl.code = code; msg->rpl.id = dh6msg->req.id; if ( !memcmp(&sdest->sin6_addr, agent, IPV6_ADDR_LEN) || (dh6msg->rel.type == DH6_RELEASE && !dh6msg->rel.Dbit)) { to6.sin6_port = htons(DH6_AGENT_PORT); msg->rpl.Lbit = 1; set_reply_llocal_addr(&msg->rpl, lladdr); } else { to6.sin6_port = htons(DH6_CLIENT_PORT); msg->rpl.Lbit = 0; } len = sizeof(struct dh6_reply) + msg->rpl.Lbit*IPV6_ADDR_LEN; if ( extlen != 0 && ext != NULL ) { memcpy(reply_ext(&msg->rpl), ext, extlen); len += extlen; } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Reply len:%d, to: %s, port:%d", len, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _resend_reply: if (sendto(sia->sia_sk.fd, msg, len, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != len) { if ( errno==EINTR ) goto _resend_reply; if ( errno==EINVAL ) { log_info("Resending DHC Reply"); goto _resend_reply; } log_sys_warn(3045, "fd(%d):sendto", sia->sia_sk.fd); } return 0; } int svr_reconfigure_send( struct svr_ifaddr *sia, /* server entry */ struct in6_addr *dest, /* destination address */ int extlen, /* length of extensions */ void *ext) /* extensions */ { struct sockaddr_in6 to6; u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg = (DH6_MESSAGE *)buf; int len; bzero((char *)&to6, sizeof(to6)); to6.sin6_family = AF_INET6; memcpy(&to6.sin6_addr, dest, IPV6_ADDR_LEN); to6.sin6_port = htons(DH6_CLIENT_PORT); bzero((char *)msg, MAX_MSG_LEN); msg->conf.type = DH6_RECONFIGURE; len = sizeof(struct dh6_reconfigure); if ( extlen != 0 && ext != NULL ) { memcpy(msg->conf.ext, ext, extlen); len += extlen; } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("sending DHC Reconfigure len:%d, to: %s, port:%d", len, inet_ntop(AF_INET6, &to6.sin6_addr, 16, NULL), ntohs(to6.sin6_port)); #endif _resend_reconfigure: if (sendto(sia->sia_sk.fd, msg, len, 0, (struct sockaddr *)&to6, sizeof(struct sockaddr_in6)) != len) { if ( errno==EINTR ) goto _resend_reconfigure; if ( errno==EINVAL ) { log_info("Resending DHC Reconfigure"); goto _resend_reconfigure; } log_sys_warn(3046, "fd(%d):sendto", sia->sia_sk.fd); } return 0; } sc->sc_state = SC_STATE_DELETE; dh6db_put(db2, sc, R_NOOVERWRITE); dh6db_sync(db2,R_RECNOSYNC); } dh6db_close(db2); dh6db_close(db); return 0; } static void svr_run_unix_server( void * data ) { struct fd_list *p = (struct fd_list *)data, *fdp; int fd; struct sockaddr_un unix_addr; int unix_len = sizeof(unix_addr); for (;;) { dhcpv6-1.0/dh6_svr.h010060000015740003721000000072430625233634200145230ustar00yunzhouip00000400000004/* * dh6_svr.h DHCPv6 Server Data Structures * * Version: @(#)dh6_svr.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __DH6_SVR_H #define __DH6_SVR_H #define SVR_DB_CHECK_INTERVAL 60 /* db is checked every 60 seconds */ #define DH6_SVR_INUSE "dh6_svr_inuse.db" #define DH6_SVR_INVAL "dh6_svr_inval.db" #define DH6_NEWADDR "dh6_newaddress" #define DH6SVR_CONF "dh6_server.conf" #define SVR_CONF_PATH "/etc/" /* * Client list */ struct svr_client { struct svr_client *next; struct svr_client *prev; struct svr_ifaddr *sc_sia; /* a server address */ struct in6_addr sc_lladdr; /* client link local (net-order) */ struct in6_addr sc_rlyaddr; /* relay address (net-order) */ struct in6_addr sc_cliaddr; /* client address (net-order) */ u_int16_t sc_id; /* transaction ID (host-order) */ u_int8_t sc_prfsize; /* prefix size */ #define SC_STATE_NONE 0 /* no address */ #define SC_STATE_TEMP 1 /* temporary address */ #define SC_STATE_PREFER 2 /* preferred address */ #define SC_STATE_VALID 3 /* valid address */ #define SC_STATE_DELETE 4 /* invalid address */ u_int8_t sc_state; /* Client state */ u_int32_t sc_valid_life; /* seconds (host order) */ u_int32_t sc_prefer_life;/* seconds (host order) */ struct u_timer sc_xmit_timer; /* transmission timer */ u_int16_t sc_xmit_timeout;/*remaining time */ struct u_timer sc_dns_timer; /* timer for updating DNS */ }; /* * Server Address list */ struct svr_ifaddr { struct svr_ifaddr *next; struct svr_ifaddr *prev; IF_INFO *sia_ifi; /* interface information */ struct in6_addr sia_addr; /* address (net order) */ UNION_LIST sia_clilist; /* client hash table */ struct fd_list sia_sk; /* socket for server address */ #define SERVER_DEFAULT_LIFETIME 1 u_int8_t sia_lifetime; /* server advertisement lifetime */ }; struct svr_record { struct in6_addr svraddr; /* client link local (net-order) */ struct in6_addr lladdr; /* client link local (net-order) */ struct in6_addr rlyaddr; /* relay address (net-order) */ struct in6_addr cliaddr; /* client address (net-order) */ u_int16_t id; /* transaction ID (host-order) */ u_int8_t prfsize; /* prefix size */ u_int8_t state; /* Client state */ u_int32_t prefer_life; /* seconds (host order) */ u_int32_t valid_life; /* seconds (host order) */ }; extern struct svr_client * sc_create( void ); extern inline void sc_destroy( struct svr_client *); extern struct svr_client * sc_get( struct svr_ifaddr *, struct in6_addr *, struct in6_addr *); extern struct svr_ifaddr * sia_create( void ); extern inline void sia_destroy( struct svr_ifaddr *sia ); extern struct svr_ifaddr * sia_get(struct in6_addr *addr); #endif /* __DH6_SVR_H */ dhcpv6-1.0/dh6_svrcmd.c010060000015740003721000000162270625233634200152040ustar00yunzhouip00000400000004/* * dh6_svrcmd.c DHCPv6 Client Daemon * * Version: @(#)dh6_svrcmd.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "localdefs.h" #include "u_timer.h" #include "dispatch.h" #include "u_buf.h" #include "dh6.h" #include "ext6.h" #include "dh6_if.h" #include "dh6_svr.h" #include "dh6_adm.h" #include "sock.h" extern char *optarg; extern int optind, opterr, optopt; int debug = 0; /* * Generate an error message with the printf facility. */ void p_error (int err, const char *ctl, ...) { char buf[1000]; va_list list; va_start (list,ctl); vsprintf (buf,ctl,list); printf("error %d: %s\n", err, buf); } main( int argc, char * argv[] ) { int optval; char op; u_int8_t buf[MAX_MSG_LEN]; ADM_MESSAGE *msg=(ADM_MESSAGE *)buf; DH6_MESSAGE *dh6=(DH6_MESSAGE *)(&msg->un.dh6.msg); struct sockaddr_un serv_addr; int sockfd, servlen, msglen; if ( argc<2 ) cmd_usage(); opterr = 0; while ((op = getopt(argc-1, argv+1, "d:D:")) != EOF) { switch (op) { #ifdef DH6_DEBUG case 'd': /* debug */ case 'D': /* debug */ debug = atoi(optarg); break; #endif default: } } if ( strcmp(argv[1],"start")==0 ) { char cmd[50]; sprintf(cmd, "%sdh6sd -d%d", DH6_SERV_PATH, debug); system(cmd); exit(0); } else if ( strcmp(argv[1],"restart")==0 ) { char cmd[50]; sprintf(cmd, "%s stop", argv[0]); system(cmd); sleep(1); sprintf(cmd, "%s start -d%d", argv[0], debug); system(cmd); exit(0); } else if ( strcmp(argv[1],"stop")!=0 && strcmp(argv[1],"reconf")!=0 && strcmp(argv[1],"dbshow")!=0 ) cmd_usage(); bzero((char *) &serv_addr, sizeof(serv_addr)); serv_addr.sun_family = AF_UNIX; strcpy(serv_addr.sun_path, dh6svr_adm_server_name()); servlen = strlen(serv_addr.sun_path) + sizeof(serv_addr.sun_family) + 1; if ( (sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) p_error(3201, strerror(errno)); if (connect(sockfd, (struct sockaddr *) &serv_addr, servlen) < 0) p_error(3202, strerror(errno)); memset(buf, 0, MAX_MSG_LEN); if ( strcmp(argv[1],"stop")==0 ) { msg->cmd = ADM_CMD_STOP; msg->len = 0; msglen = 4; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } if ( strcmp(argv[1],"dbshow")==0 ) { struct in6_addr addr; msg->cmd = ADM_SHOW_DB; while ((op=getopt(argc-1,argv+1,"l:L:a:A:v:V:"))!=EOF) { switch (op) { case 'l': case 'L': inet_pton(AF_INET6, optarg, &addr); memcpy(&msg->un.sdb.lladdr, &addr, IPV6_ADDR_LEN); msg->bit0 = 1; break; case 'a': case 'A': inet_pton(AF_INET6, optarg, &addr); memcpy(&msg->un.sdb.agent, &addr, IPV6_ADDR_LEN); msg->bit1 = 1; break; case 'v': case 'V': inet_pton(AF_INET6, optarg, &addr); memcpy(&msg->un.sdb.client, &addr, IPV6_ADDR_LEN); msg->bit2 = 1; break; } } msg->len = ADM_SVRDB_LEN; msglen = 4 + msg->len; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } if ( strcmp(argv[1],"reconf")==0 ) { struct in6_addr addr, client; u_int8_t *ext = NULL; int extlen = 0; int prefer = DH6_DEFAULT_PREFER_TIME, valid = DH6_DEFAULT_VALID_TIME, v_flag = 0; msg->cmd = ADM_DH6_MSG; msg->un.dh6.lport = DH6_AGENT_PORT; msg->un.dh6.fport = DH6_CLIENT_PORT; dh6->req.type = DH6_RECONFIGURE; while ((op=getopt(argc-1,argv+1,"s:S:a:A:v:V:l:L:"))!=EOF) { switch (op) { case 's': case 'S': inet_pton(AF_INET6, optarg, &addr); memcpy(&msg->un.dh6.laddr, &addr, IPV6_ADDR_LEN); break; case 'a': case 'A': inet_pton(AF_INET6, optarg, &addr); memcpy(&msg->un.dh6.faddr, &addr, IPV6_ADDR_LEN); break; case 'v': case 'V': inet_pton(AF_INET6, optarg, &client); v_flag = 1; break; case 'l': prefer = atoi(optarg); break; case 'L': valid = atoi(optarg); break; } } msg->len = ADM_DH6MSG_HDRLEN + sizeof(struct dh6_reconfigure); append_addr_ext6(ext, &extlen, (v_flag) ? &client : NULL, 0, prefer, valid, NULL, 0, 0, 0); if ( extlen != 0 && ext != NULL ) { memcpy(buf+4+msg->len, ext, extlen); msg->len += extlen; } msglen = msg->len + 4; cmd_sendto_serv( sockfd, msg, msglen ); goto out; } out: close(sockfd); exit(0); } cmd_usage( void ) { printf("usage: dh6sc start -d\n"); printf(" dh6sc restart -d\n"); printf(" dh6sc stop\n"); printf(" dh6sc reconf -s -a -v -l -L\n"); printf(" dh6sc dbshow -l -a -v\n"); exit(1); } /* * send a message to server */ int cmd_sendto_serv( int sockfd, ADM_MESSAGE *msg, int msglen ) { if ( send(sockfd, msg, msglen, 0) != msglen) { p_error(3203, strerror(errno)); return -1; } return 0; } to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "localdefs.h" #include "u_timer.h" #include "dispatch.h" #include "u_buf.h" #includdhcpv6-1.0/dh6all.h010060000015740003721000000001250625233634200143120ustar00yunzhouip00000400000004#ifdef DIGITAL_UNIX #include "digital.h" #elif NETBSD #include "netbsd.h" #endif dhcpv6-1.0/dh6cc.8010060000015740003721000000042370625233634300140600ustar00yunzhouip00000400000004.\" This program is distributed according to the Gnu General Public License. .\" See the file COPYING in this directory .\" .\" .TH DH6CC 8 "Dec 8, 1996" NetBSD "DHCPv6" .SH NAME dh6cc \- DHCPv6 client command program .SH SYNOPSIS .B dh6cc start .br .B dh6cc restart .br .B dh6cc stop .br .B dh6cc open \-i .br .B dh6cc close \-i .br .B dh6cc dbshow dbshow \-s \-a \-v .br .B dh6cc solicit \-i \-p \-c .br .B dh6cc request \-i \-s \-a \-c \-v \-q \-l \-L .br .B dh6cc release \-i \-s \-a \-x \-t .br .SH DESCRIPTION .B dh6cc is used to send commands to DHCPv6 client daemons .B dh6cd. Once .B dh6cd receives a command from .B dh6cc , it stops, restart the daemon, displays some debugging information, or forwards DHCPv6 messages to relevant sockets. As the daemon is hard to decide when it should send Release or a specific Request, these messages can be input by this command program. .PP The options are as follows: .TP 8 \-d The \-d option defines debugging level. .TP 8 \-i The \-i option specifies interface, such as le0, le1 and so on. .TP 8 \-s The \-s option specifies server address. .TP 8 \-a The \-a option specifies agent address. .TP 8 \-v The \-v option specifies client address, which is assigned by server. .TP 8 \-p The \-p option requests previous servers in cache to be returned. .TP 8 \-c The \-c option requests server to release unknow parameters. .TP 8 \-q The \-q option means that client's request for the address extension is mandatory. Server should honor the parameter or deny it. .TP 8 \-l The \-l option defines preferred lifetime. .TP 8 \-L The \-L option defines valid lifetime. .TP 8 \-x The \-x option defines a specific transaction identification. .TP 8 \-t The \-t option requests the message to be sent directly. .SH FILES etc/dh6_client.conf .SH SEE ALSO dh6sc(8) dh6rc(8) .SH HISTORY The dh6cc utility was initially created in December 1996 by Yunzhou Li . Hopefully, it can be improved. .SH BUGS .B dh6cc relies on getting valid input although it only pretends to know anything about it... dhcpv6-1.0/dh6rc.8010060000015740003721000000020700625233634300140700ustar00yunzhouip00000400000004.\" This program is distributed according to the Gnu General Public License. .\" See the file COPYING in this directory .\" .\" .TH DH6RC 8 "Dec 8, 1996" NetBSD "DHCPv6" .SH NAME dh6rc \- DHCPv6 relay command program .SH SYNOPSIS .B dh6rc start .br .B dh6rc restart .br .B dh6rc stop .br .B dh6rc solicit \-s \-a .br .SH DESCRIPTION .B dh6rc is used to send commands to DHCPv6 relay daemons .B dh6rd. Once .B dh6rd receives a command from .B dh6rc , it stops, restart the daemon, displays some debugging information, or forwards DHCPv6 messages to relevant sockets. .PP The options are as follows: .TP 8 \-d The \-d option defines debugging level. .TP 8 \-s The \-s option specifies server address. .TP 8 \-a The \-a option specifies agent address. .TP 8 .SH FILES etc/dh6_relay.conf .SH SEE ALSO dh6cc(8) dh6sc(8) .SH HISTORY The dh6rc utility was initially created in December 1996 by Yunzhou Li . Hopefully, it can be improved. .SH BUGS .B dh6rc relies on getting valid input although it only pretends to know anything about it... dhcpv6-1.0/dh6sc.8010060000015740003721000000030730625233634300140750ustar00yunzhouip00000400000004.\" This program is distributed according to the Gnu General Public License. .\" See the file COPYING in this directory .\" .\" .TH DH6SC 8 "Dec 8, 1996" NetBSD "DHCPv6" .SH NAME dh6sc \- DHCPv6 server command program .SH SYNOPSIS .B dh6sc start .br .B dh6sc restart .br .B dh6sc stop .br .B dh6sc dbshow dbshow \-l \-a \-v .br .B dh6sc reconf \-s \-a \-v \-l \-L .br .SH DESCRIPTION .B dh6sc is used to send commands to DHCPv6 server daemons .B dh6sd. Once .B dh6sd receives a command from .B dh6sc , it stops, restart the daemon, displays some debugging information, or forwards DHCPv6 messages to relevant sockets. As the daemon is hard to decide when it should send Reconfigure message, this message can be input by this command program. .PP The options are as follows: .TP 8 \-d The \-d option defines debugging level. .TP 8 \-s The \-s option specifies server address. .TP 8 \-a The \-a option specifies agent address for "dbshow", or destination address for "reconf". .TP 8 \-v The \-v option specifies client address, which is assigned by server. .TP 8 \-l The \-l option defines preferred lifetime for "reconf", or specifies link-local address for "dbshow". .TP 8 \-L The \-L option defines valid lifetime. .SH FILES etc/dh6_server.conf .SH SEE ALSO dh6cc(8) dh6rc(8) .SH HISTORY The dh6sc utility was initially created in December 1996 by Yunzhou Li . Hopefully, it can be improved. .SH BUGS .B dh6sc relies on getting valid input although it only pretends to know anything about it... dhcpv6-1.0/digital.h010060000015740003721000000015310625233634300145600ustar00yunzhouip00000400000004#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include dhcpv6-1.0/dispatch.c010060000015740003721000000066140625233634300147440ustar00yunzhouip00000400000004/* * dispatch.c Dispatch Module * * Version: @(#)dispatch.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include #include #include #include #include #include "u_timer.h" #include "dispatch.h" extern int debug; static int fd_list_lock_flag = 0; inline void lock_fd_list( void ) { fd_list_lock_flag = 1; } inline void unlock_fd_list( void ) { fd_list_lock_flag = 0; } inline int fd_list_locked( void ) { return fd_list_lock_flag; } static struct fd_list fdp_head = { &fdp_head, &fdp_head, FD_SETSIZE, NULL, NULL }; static int nfds = 0; int reset_fd_list( void ) { fdp_head.next = &fdp_head; fdp_head.prev = &fdp_head; fdp_head.fd = FD_SETSIZE; fdp_head.data = NULL; fdp_head.function = NULL; } void init_fdp(struct fd_list * fdp) { fdp->next = NULL; fdp->prev = NULL; } static void reset_nfds( void ) { if (fdp_head.prev == &fdp_head) nfds = 0; else nfds = fdp_head.prev->fd + 1; } void add_fdp(struct fd_list * fdp) { struct fd_list *p; p = &fdp_head; do { p = p->next; } while (fdp->fd > p->fd); lock_fd_list(); fdp->next = p; fdp->prev = p->prev; p->prev = fdp; fdp->prev->next = fdp; unlock_fd_list(); reset_nfds(); } void del_fdp(struct fd_list * fdp) { if (fdp->next) { struct fd_list * next; if ((next = fdp->next) != NULL) { lock_fd_list(); (next->prev = fdp->prev)->next = next; fdp->next = fdp->prev = NULL; reset_nfds(); unlock_fd_list(); return; } } return; } int dispatch( void ) { fd_set readfds; int rtn = 0; struct fd_list *p, *p2; if ( fd_list_locked() ) return; FD_ZERO(&readfds); p = fdp_head.next; while (p->fd > 0 && p->fd < FD_SETSIZE) { FD_SET(p->fd, &readfds); p = p->next; } /* To allow timer interrupt */ if ( (rtn=select(nfds, &readfds, NULL, NULL, NULL)) < 0) { if (errno == EINTR) { signal(SIGALRM, run_timer_table); return -1; } else log_sys_warn(101,"select"); } if (rtn == 0) return 0; p = fdp_head.next; while (p->fd > 0 && p->fd < FD_SETSIZE) { void (*fn)(void *) = p->function; #ifdef DH6_DEBUG if ( look_dp_more() ) log_info("pid(%d)-dispatch(): fd=%d", getpid(), p->fd); #endif p2 = p; /* in case fn() may remove the current fdp for the queue */ p = p->next; if (FD_ISSET(p2->fd, &readfds)) { void *data = p2->data; fn(data); } } return rtn; } void clean_fd_list( void ) { struct fd_list *p, *p2; p = fdp_head.next; while (p->fd >= 0 && p->fd < FD_SETSIZE) { p2 = p; p = p->next; del_fdp( p2 ); close( p2->fd ); } } dhcpv6-1.0/dispatch.h010060000015740003721000000024410625233634300147430ustar00yunzhouip00000400000004/* * dispatch.h Dispatch Structures * * Version: @(#)dispatch.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __DISPATCH_H #define __DISPATCH_H struct fd_list { struct fd_list *next; struct fd_list *prev; int fd; void *data; void (*function)(void *); }; extern void init_fdp(struct fd_list *); extern void add_fdp(struct fd_list *); extern void del_fdp(struct fd_list *); extern int dispatch(void); extern void clean_fd_list( void ); #endif /* __DISPATCH_H */ dhcpv6-1.0/ext6.c010060000015740003721000000161130625233634300140260ustar00yunzhouip00000400000004/* * ext6.c Extensions for DHCPv6 * * Version: @(#)ext6.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "dh6.h" #include "ext6.h" /* length of address extension */ inline int ext6_addr_len(struct ext6_addr *ext) { return sizeof(struct ext6_addr) + ext->Cbit * IPV6_ADDR_LEN + #ifdef TODO strlen(get_ext6_addr_dns_name(ext)) + 1 + #endif ext->Lbit * sizeof(u_int32_t) * 2; } /* client address if present */ inline struct in6_addr * get_ext6_addr_client_addr( struct ext6_addr *ext ) { if ( ext->Cbit ) return( (struct in6_addr *) (ext->data) ); else return NULL; } inline void set_ext6_addr_client_addr( struct ext6_addr *ext, struct in6_addr *cliaddr ) { if ( !ext->Cbit ) return; memcpy(ext->data, cliaddr, IPV6_ADDR_LEN); } /* preferred lifetime if present */ inline u_int32_t get_ext6_addr_prefer_lifetime( struct ext6_addr *ext ) { if ( ext->Lbit ) return( *((u_int32_t *)(ext->data + ext->Cbit*sizeof(struct in6_addr))) ); else return 0; } inline void set_ext6_addr_prefer_lifetime( struct ext6_addr *ext, u_int32_t lifetime ) { if ( !ext->Lbit ) return; *((u_int32_t *)(ext->data + ext->Cbit*sizeof(struct in6_addr))) = lifetime; } /* valid lifetime if present */ inline u_int32_t get_ext6_addr_valid_lifetime( struct ext6_addr *ext ) { if ( ext->Lbit ) return( *((u_int32_t *)(ext->data + ext->Cbit*sizeof(struct in6_addr) + ext->Lbit*sizeof(u_int32_t))) ); else return 0; } inline void set_ext6_addr_valid_lifetime( struct ext6_addr *ext, u_int32_t lifetime ) { if ( !ext->Lbit ) return; *((u_int32_t *)(ext->data + ext->Cbit*sizeof(struct in6_addr) + ext->Lbit*sizeof(u_int32_t))) = lifetime; } /* DNS name if present */ inline char * get_ext6_addr_dns_name( struct ext6_addr *ext ) { return( (char *)(ext->data + ext->Cbit*sizeof(struct in6_addr) + ext->Lbit*sizeof(u_int32_t)*2) ); } inline void set_ext6_addr_dns_name( struct ext6_addr *ext, char *dns ) { strcpy( (char *)(ext->data + ext->Cbit*sizeof(struct in6_addr) + ext->Lbit*sizeof(u_int32_t)*2), dns ); } /* directory agent address if present */ inline struct in6_addr * get_ext6_da_addr( struct ext6_da *ext ) { if ( ext->Dbit ) return( (struct in6_addr *) (ext->data) ); else return NULL; } inline void set_ext6_da_addr( struct ext6_da *ext, struct in6_addr *addr ) { if ( !ext->Dbit ) return; memcpy(ext->data, addr, IPV6_ADDR_LEN); } /* Scope list: if there is nothing in Scope list, does this list include only '\0'? */ char ** get_ext6_da_scope_list( struct ext6_da *ext) { static char **p=NULL; register int i; p = (char **)realloc( p, ext->ScopeCnt*sizeof(char *) ); p[0] = ext->data + ext->Dbit*sizeof(struct in6_addr); for (i=1; iScopeCnt; i++) p[i] = p[i-1] + strlen(p[i-1]) + 1; return( p ); } void set_ext6_da_scope_list( struct ext6_da *ext, char *list[] ) { char *p; register int i, pos = 0; p = ext->data + ext->Dbit*sizeof(struct in6_addr); for (i=1; iScopeCnt; i++) { strcpy(p+pos, list[i]); pos += strlen(list[i]) + 1; } } /* destination addresses */ inline struct in6_addr * get_ext6_static_route_dest( struct ext6_static_route *ext, int seqno ) { if ( (seqno+1)*32 > ext->len ) return NULL; return( (struct in6_addr *) (ext->a[seqno]) ); } inline void set_ext6_static_route_dest( struct ext6_static_route *ext, int seqno, struct in6_addr *dest ) { if ( (seqno+1)*32 > ext->len ) return; memcpy(ext->a[seqno], dest, IPV6_ADDR_LEN); } /* router addresses */ inline struct in6_addr * get_ext6_static_route_router( struct ext6_static_route *ext, int seqno ) { if ( (seqno+1)*32 > ext->len ) return NULL; return( (struct in6_addr *) (ext->a[seqno] + sizeof(struct in6_addr)) ); } inline void set_ext6_static_route_router( struct ext6_static_route *ext, int seqno, struct in6_addr *router ) { if ( (seqno+1)*32 > ext->len ) return; memcpy(ext->a[seqno]+IPV6_ADDR_LEN, router, IPV6_ADDR_LEN); } /* locate a specific extension */ u_int8_t * ext6_get(int code, void *ext6, int len) { u_int8_t *ext = (u_int8_t *)ext6, *end = ext + len - 1; while (ext <= end) { int code2 = ntohs(*((u_int16_t *)ext)); if (code2 == code) return ext; if (code2 == EXT6_END) return NULL; if (ext+1 == end && *ext == EXT6_PAD) return NULL; ext += 4 + ntohs(*((u_int16_t *)(ext+2))); } return NULL; } void * append_addr_ext6( void *ext, /* original extensions */ int *len, /* length of original extensions */ struct in6_addr *cliaddr, /* client address */ int PrfSize, /* prefix size */ u_int32_t prefer, /* preferred lifetime */ u_int32_t valid, /* valid lifetime */ char *dns, /* DNS Name */ u_int8_t Qbit, /* Required bit */ u_int8_t Abit, /* AAAA bit */ u_int8_t Pbit) /* new PTR bit */ { struct ext6_addr *p; void *ext2; void *tmp = malloc(*len); int newlen = sizeof(struct ext6_addr); memcpy(tmp, ext, *len); if ( cliaddr ) newlen += IPV6_ADDR_LEN; if (prefer != 0) newlen += 2 * sizeof(u_int32_t); if (dns != NULL) newlen += strlen(dns) + 1; if ( ext ) ext2 = realloc(ext, *len+newlen); else ext2 = malloc(*len+newlen); memcpy(ext2, tmp, *len); free(tmp); p = (struct ext6_addr *)( ((u_int8_t *)ext2) + *len ); *len += newlen; p->code = htons(EXT6_ADDR); p->len = htons(newlen - 4); p->Cbit = (cliaddr != NULL); p->Lbit = (prefer != 0); p->Qbit = Qbit; p->Abit = Abit; p->Pbit = Pbit; p->PrfSize = PrfSize; if ( cliaddr ) set_ext6_addr_client_addr(p, cliaddr); if ( p->Lbit ) { set_ext6_addr_prefer_lifetime(p, prefer); set_ext6_addr_valid_lifetime(p, valid); } if ( dns ) set_ext6_addr_dns_name(p, dns); return ext2; } void * svr_append_multicast_ext6( void *ext, /* original extensions */ int *len, /* length of original extensions */ struct in6_addr *addr) /* multicast address */ { struct ext6_multicast *p; void *ext2; void *tmp = malloc(*len); int newlen = sizeof(struct ext6_multicast); memcpy(tmp, ext, *len); if ( ext ) ext2 = realloc(ext, *len+newlen); else ext2 = malloc(*len+newlen); memcpy(ext2, tmp, *len); free(tmp); p = (struct ext6_multicast *)( ((u_int8_t *)ext2) + *len ); *len += newlen; p->code = htons(EXT6_MULTICAST); p->len = htons(newlen - 4); memcpy(&p->addr, addr, IPV6_ADDR_LEN); return ext2; } dhcpv6-1.0/ext6.h010060000015740003721000000166670625233634300140510ustar00yunzhouip00000400000004/* * ext6.c Extensions Structures for DHCPv6 * * Version: @(#)ext6.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __EXT6_H #define __EXT6_H /* * DHCPv6 Pad Extension */ struct ext6_pad { #define EXT6_PAD 0 u_int8_t code; }; /* * DHCPv6 End Extension */ struct ext6_end { #define EXT6_END 65535 u_int16_t code; }; /* * DHCPv6 Address Extension */ struct ext6_addr { #define EXT6_ADDR 1 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t rsvd1:3, Pbit:1, /* P for PTR record ??? */ Abit:1, /* A for AAAA record ??? */ Qbit:1, /* Q for required by client */ Lbit:1, /* L for preferred and valid Lifetime */ Cbit:1; /* C for Client address */ u_int8_t rsvd2; u_int8_t rsvd3; u_int8_t PrfSize; /* Prefix size for client address */ u_int8_t data[0]; }; /* length of address extension */ extern int ext6_addr_len(struct ext6_addr *); /* client address if present */ extern struct in6_addr * get_ext6_addr_client_addr(struct ext6_addr *); extern void set_ext6_addr_client_addr(struct ext6_addr *, struct in6_addr *); /* preferred lifetime if present */ extern u_int32_t get_ext6_addr_prefer_lifetime(struct ext6_addr *); extern void set_ext6_addr_prefer_lifetime(struct ext6_addr *, u_int32_t); /* valid lifetime if present */ extern u_int32_t get_ext6_addr_valid_lifetime(struct ext6_addr *); extern void set_ext6_addr_valid_lifetime(struct ext6_addr *, u_int32_t); /* DNS name if present */ extern char * get_ext6_addr_dns_name(struct ext6_addr *); extern void set_ext6_addr_dns_name(struct ext6_addr *, char *); /* * DHCPv6 Time Offset Extension */ struct ext6_time_offset { #define EXT6_TIMEOFFSET 8 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t n1; /* time offset */ u_int8_t n2; /* time offset */ u_int8_t n3; /* time offset */ u_int8_t n4; /* time offset */ }; /* * DHCPv6 Domain Name Server Extension */ struct ext6_dns { #define EXT6_DNS 9 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t a[1][16]; /* addresses, could be multiple 16 */ }; /* * DHCPv6 Domain Name Extension */ struct ext6_dom_name { #define EXT6_DOM_NAME 10 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t d[1]; }; /* * DHCPv6 Directory Agent Extension */ struct ext6_da { #define EXT6_DA 16 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t ScopeCnt; /* scope count */ u_int8_t rsvd1:6, Mbit:1, /* M for DA address used only */ Dbit:1; /* D for Directory agent address */ u_int16_t rsvd2; u_int8_t data[0]; }; /* directory agent address if present */ extern struct in6_addr * get_ext6_da_addr(struct ext6_da *); extern void set_ext6_da_addr(struct ext6_da *, struct in6_addr *); /* Scope list: if there is nothing in Scope list, does this list include only '\0'? */ extern char ** get_ext6_da_scope_list(struct ext6_da *); extern void set_ext6_da_scope_list(struct ext6_da *, char *[]); /* * DHCPv6 Service Scope Extension */ struct ext6_sa { #define EXT6_SA 17 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t scope[0]; }; #ifdef DELETED_IN_DRAFT_08 /* * DHCPv6 Naming Authority Extension */ struct ext6_name_auth { #define EXT6_NAME_AUTH 13 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t auth[0]; }; #endif /* * DHCPv6 Static Route Extension */ struct ext6_static_route { #define EXT6_STATIC_ROUTE 24 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t a[1][32]; /* addresses, could be multiple of 32 */ }; /* destination addresses */ extern struct in6_addr * get_ext6_static_route_dest(struct ext6_static_route *, int); extern void set_ext6_static_route_dest(struct ext6_static_route *, int, struct in6_addr *); /* router addresses */ extern struct in6_addr * get_ext6_static_route_router(struct ext6_static_route *, int); extern void set_ext6_static_route_router(struct ext6_static_route *, int, struct in6_addr *); /* * DHCPv6 TCP Default TTL Extension */ struct ext6_tcp_ttl { #define EXT6_TCP_TTL 32 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t ttl[4]; /* TTL */ }; #ifdef DELETED_IN_DRAFT_08 /* * DHCPv6 TCP Keepalive Interval Extension */ struct ext6_tcp_interval { #define EXT6_TCP_INTVL 38 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t t1; /* time */ u_int8_t t2; /* time */ u_int8_t t3; /* time */ u_int8_t t4; /* time */ }; #endif /* * DHCPv6 Vendor Specific Information Extension */ struct ext6_vendor_info { #define EXT6_VENDOR 40 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t info[0]; /* Vendor Specific Information */ }; /* * DHCPv6 Maximum Message Size Extension */ struct ext6_max_msg_size { #define EXT6_MSG_SIZE 64 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ #define DHCPV6_MIN_SIZE 1500 u_int16_t l[2]; }; /* * DHCPv6 Class Identifier Extension */ struct ext6_class_id { #define EXT6_CLASS_ID 65 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t i[1]; /* class identifier */ }; /* * DHCPv6 Reconfigure Multicast Address Extension */ struct ext6_multicast { #define EXT6_MULTICAST 66 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ struct in6_addr addr; /* multicast address */ }; /* * DHCPv6 Renumber Server Address Extension */ struct ext6_renum_server { #define EXT6_RENUM_SVR 67 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int8_t a[16]; /* multicast address */ }; /* * DHCPv6 Client-Server Authentication Extension */ struct ext6_authen { #define EXT6_AUTHEN 80 u_int16_t code; /* extension type code */ u_int16_t len; /* extension length */ u_int16_t sp[4]; /* Security Parameter Index */ u_int32_t rp[8]; /* relay protect */ u_int8_t auth[0]; /* authenticator */ }; extern u_int8_t * ext6_get(int, void *, int); extern void * append_addr_ext6(void *, int *, struct in6_addr *, int, u_int32_t, u_int32_t, char *, u_int8_t, u_int8_t, u_int8_t); #define CLI_APPEND_ADDR_EXT6(ext, len, prefer, valid, Qbit) \ append_addr_ext6(ext, len, NULL, 0, prefer, valid, \ NULL, Qbit, 0, 0) #define SVR_APPEND_ADDR_EXT6(ext,len,cliaddr,PrfSize,prefer,valid) \ append_addr_ext6(ext, len, cliaddr, PrfSize, prefer, valid, \ NULL, 0, 0, 0) extern void * svr_append_multicast_ext6( void *, int *, struct in6_addr *); #endif /* __EXT6_H */ t ext6_dom_name { #define EXT6_DOM_NAME 10 u_int16_t code; /* extensidhcpv6-1.0/inettrans.c010060000015740003721000000141720625233634300151520ustar00yunzhouip00000400000004/* * IPv6 address translation routines inet_ntop() and inet_pton() * as defined in draft-ietf-ipngwg-bsd-api-05 * * Author: Peter Belding * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. */ #include #include #include #include #include static char inet_ntop_buffer[46]; static char hexc[] = "0123456789abcdef"; char *inet_ntop(int af, const void *ap, size_t len, char *cp) { int value; if (ap == NULL) return NULL; if (cp == NULL) cp = inet_ntop_buffer; if (af == AF_INET) { u_char *p = (u_char *)ap; if (len < 4) return NULL; sprintf(cp, "%d.%d.%d.%d",p[0], p[1], p[2], p[3]); return cp; } else if (af == AF_INET6) { struct in6_addr *addr = (struct in6_addr *)ap; char *tmp = cp; int start = -1, count = 0, i; if (len < 16) return NULL; /* weird special cases for IPv4 address */ if ((addr->s6_addr32[0] == 0) && (addr->s6_addr32[1] == 0)) { if (addr->s6_addr32[2] == 0) { if (addr->s6_addr32[3] == 0) { strcpy(cp,"::"); } else if (ntohl(addr->s6_addr32[3]) <= 0xff) { sprintf(cp,"::%x",addr->s6_addr[15]); } else sprintf(cp,"::%d.%d.%d.%d", addr->s6_addr[12], addr->s6_addr[13], addr->s6_addr[14], addr->s6_addr[15]); return cp; } else if (addr->s6_addr32[2] == htonl(0xffff)) { sprintf(cp,"::ffff:%d.%d.%d.%d", addr->s6_addr[12], addr->s6_addr[13], addr->s6_addr[14], addr->s6_addr[15]); return cp; } } /* * Find the first string of consecutive __u16 zeros */ for (i = 0; i < 8; i++) { if ((addr->s6_addr[2*i] == 0) && (addr->s6_addr[2*i+1] == 0)) { if (start > -1) { count++; } else { start = i; count = 1; } } else { if (count > 1) { break; } else { start = -1; count = 0; } } } if (start == 0) *tmp++ = ':'; for (i = 0; i < 8; i++) { if (i == start) { *tmp++ = ':'; i += count-1; } else { int value = (addr->s6_addr[2*i] << 8) | addr->s6_addr[2*i+1]; if (value >> 12) *tmp++ = hexc[(value>>12)&0xf]; if (value >> 8) *tmp++ = hexc[(value>>8)&0xf]; if (value >> 4) *tmp++ = hexc[(value>>4)&0xf]; *tmp++ = hexc[value & 0xf]; if (i != 7) *tmp++ = ':'; } } *tmp = '\0'; return cp; } else return NULL; } int inet_pton(int af, const char *s, void *ap) { if (ap == NULL) return -1; if (af == AF_INET) { unsigned int addr = inet_addr(s); *(unsigned int *)ap = addr; return 4; } else if (af == AF_INET6) { const char *tmp = s; int ccount = 0, pos = 0; int value = 0, lastcolon = 0; struct in6_addr addr; int v4[4]; /* quick and dirty tests for IPv4 compatible addresses */ memset(&addr,0,sizeof(struct in6_addr)); if (sscanf(s, "::%d.%d.%d.%d",&v4[0],&v4[1],&v4[2],&v4[3]) == 4 ) { for (pos=0; pos < 4;pos++) addr.s6_addr[pos+12] = v4[pos] & 0xff; memcpy(ap, &addr, sizeof(addr)); return sizeof(addr); } if (sscanf(s, "::%x:%d.%d.%d.%d", &value, &v4[0], &v4[1], &v4[2], &v4[3]) == 5) { for (pos=0; pos < 4;pos++) addr.s6_addr[pos+12] = v4[pos] & 0xff; addr.s6_addr[10] = (value >> 8) & 0xff; addr.s6_addr[11] = value & 0xff; memcpy(ap, &addr, sizeof(addr)); return sizeof(addr); } for (tmp = s; *tmp != '\0'; tmp++) if (*tmp == ':') ccount++; tmp = s; value = 0; while((*tmp != '\0') && (pos < 16)) { if (*tmp == ':') { if (lastcolon) { pos += 16 - 2*ccount; lastcolon = 0; } else { addr.s6_addr[pos++] = (value >> 8) & 0xff; addr.s6_addr[pos++] = value & 0xff; value = 0; lastcolon = 1; } } else { lastcolon = 0; if ((*tmp >= '0') && (*tmp <= '9')) { value = (value << 4) | (*tmp - '0'); } else if ((*tmp >= 'A') && (*tmp <= 'F')) { value = (value << 4) | (*tmp - 'A' + 10); } else if ((*tmp >= 'a') && (*tmp <= 'f')) { value = (value << 4) | (*tmp - 'a' + 10); } else { break; } } tmp++; } addr.s6_addr[pos++] = (value >> 8) & 0xff; addr.s6_addr[pos++] = value & 0xff; if (pos < 16) return -1; memcpy(ap, &addr, sizeof(addr)); return sizeof(struct in6_addr); } return -1; } int inet6_mask(prefixlen, addr6) u_int8_t prefixlen; struct in6_addr *addr6; { u_int8_t x = (prefixlen & ~(7)) >> 3; u_int8_t y = prefixlen & (7); int i; if (prefixlen > 128) return -1; bzero((caddr_t)addr6, sizeof(struct in6_addr)); for (i = 0; i < x; i++) { addr6->s6_addr8[i] = 0xff; } addr6->s6_addr8[x] |= (256 - 0x1 << (8-y)); } u_int8_t inet6_prefixlen(addr6) struct in6_addr *addr6; { u_int8_t i, plen; u_int8_t *s = (u_int8_t *)addr6, s2; for(i = 0; i < sizeof(struct in6_addr) && s[i] == 0xff; i++) continue; if ( i == sizeof(struct in6_addr)) return i*8; for (plen = 0, s2 = 0x80; s2 > 0 && (s[i] & s2); plen++, s2 >>= 1) continue; return (i*8 + plen); } dhcpv6-1.0/localdefs.h010060000015740003721000000027260625233634300151060ustar00yunzhouip00000400000004/* * localdefs.h Some Definitions * * Version: @(#)localdefs.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __LOCALDEFS_H #define __LOCALDEFS_H typedef int boolean; #ifndef NULL #define NULL 0 #endif #define FALSE 0 #define TRUE 1 #define SUCCESS 0 #define FAILURE -1 #define ENDOFFILE -2 #define NOSOCKET -1 #define PRINT_IPV6_ADDR(addr) \ log_info(#addr": %s", \ inet_ntop(AF_INET6, addr, IPV6_ADDR_LEN, NULL)); #define PRINT_INTEGER(var) log_info(#var" = %d", var) #define PRINT_STRING(var) log_info(#var" = %s", var) #define PRINT_POINTER(var) log_info(#var" = %p", var) extern char * time_ntop(int); extern int time_pton(char *); #endif /* __LOCALDEFS_H */ dhcpv6-1.0/nd6_if.c010060000015740003721000000074400625233634300143100ustar00yunzhouip00000400000004/* * nd6_if.c * * errors 600 - 699 */ #include "dh6all.h" #include "localdefs.h" #include "u_timer.h" #include "dispatch.h" #include "u_buf.h" #include "dh6.h" #include "ext6.h" #include "nd6_if.h" #include "dh6_cli.h" #include "dh6_adm.h" UNION_LIST ifi_table; void init_ifi_table( void ) { ifi_table.ifi.head = NULL; ifi_table.ifi.tail = NULL; } int get_ifi_table( void ) { u_char buf[8192]; u_char *buf_end; struct ifconf ifc; struct ifreq *ifr; struct if_info *ifi; struct sockaddr_in6 *sin6; int s; if ((s=socket(AF_INET6, SOCK_DGRAM, 0)) < 0) log_sys(201, "socket"); ifc.ifc_len = sizeof(buf); ifc.ifc_buf = (char *)buf; if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) log_fatal(202,"SIOCGIFCONF failed"); buf_end = buf + ifc.ifc_len; ifr = ifc.ifc_req; while ((u_char *)ifr < buf_end) { sin6 = (struct sockaddr_in6 *)&ifr->ifr_addr; #ifdef DH6_DEBUG if ( look_xmit_more() ) { if ( ifr->ifr_addr.sa_family == AF_LINK ) { struct sockaddr_dl *sdl = (struct sockaddr_dl *)sin6; char ss[20]; strncpy(ss, sdl->sdl_data, sdl->sdl_nlen); log_info("AF_LINK: %s index %d", ss, sdl->sdl_index); } else if ( ifr->ifr_addr.sa_family == AF_INET6 ) log_info("AF_INET6: %s", inet_ntop(AF_INET6,&sin6->sin6_addr,16,NULL)); else if ( ifr->ifr_addr.sa_family == AF_INET ) log_info("AF_INET: %s", inet_ntoa(((struct sockaddr_in*)sin6)->sin_addr)); } #endif if ( ifr->ifr_addr.sa_family == AF_INET6 && IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ) { if ( (ifi = u_alloc_node()) == NULL ) return -1; memset(ifi, 0, sizeof(struct if_info)); strcpy(ifi->ifi_name, ifr->ifr_name); memcpy(&ifi->ifi_lladdr, &sin6->sin6_addr, sizeof(struct in6_addr)); u_queue_tail(&ifi_table, ifi); } ifr = (struct ifreq *)((char *)ifr + sizeof(ifr->ifr_name) + (sizeof(ifr->ifr_addr) > ifr->ifr_addr.sa_len ? sizeof(ifr->ifr_addr) : ifr->ifr_addr.sa_len )); } ifr = ifc.ifc_req; while ((u_char *)ifr < buf_end) { struct sockaddr_dl *sdl; if ( ifr->ifr_addr.sa_family != AF_LINK ) goto get_ifi_table_skip; sdl = (struct sockaddr_dl *)&ifr->ifr_addr; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { if ( !strncmp(ifi->ifi_name, sdl->sdl_data, sdl->sdl_nlen) ) { ifi->ifi_ifindex = sdl->sdl_index; } } get_ifi_table_skip: ifr = (struct ifreq *)((char *)ifr + sizeof(ifr->ifr_name) + (sizeof(ifr->ifr_addr) > ifr->ifr_addr.sa_len ? sizeof(ifr->ifr_addr) : ifr->ifr_addr.sa_len )); } close(s); return 0; } struct if_info * seek_ifi_byname( char *name, int len ) { struct if_info *ifi; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { if ( !strncmp(ifi->ifi_name,name,len) ) return ifi; } return NULL; } struct if_info * seek_ifi_byindex( int ifindex ) { struct if_info *ifi; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { if ( ifi->ifi_ifindex = ifindex ) return ifi; } return NULL; } struct if_info * seek_ifi_bypid( pid_t pid ) { struct if_info *ifi; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { if ( ifi->ifi_pid == pid ) return ifi; } return NULL; } void ifi_kill_dhcpv6( void ) { struct if_info *ifi; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { if ( ifi->ifi_dh6 ) kill(ifi->ifi_pid, SIGKILL); } } void print_ifi_table( void ) { struct if_info *ifi; int n = 1; for (ifi = ifi_table.ifi_head; ifi != NULL; ifi = ifi->next) { log_info("if%d: name = %s, index = %d", n++, ifi->ifi_name, ifi->ifi_ifindex); log_info(" lladdr = %s", inet_ntop(AF_INET6,&(ifi->ifi_lladdr),16,NULL)); log_info(" pid = %d, dhcpv6: %d", ifi->ifi_pid, ifi->ifi_dh6); } } dhcpv6-1.0/nd6_if.h010060000015740003721000000024450625233634300143150ustar00yunzhouip00000400000004 /* * nd6_if.h * * Interface configuration definitions for nd6hostd */ #ifndef __ND6_IF_H #define __ND6_IF_H /* * per-interface information * * XXX may need to handle multiple link local addresses per interface */ struct if_info { struct if_info *next; /* next interface */ struct if_info *prev; /* previous interface */ char ifi_name[IFNAMSIZ]; /* interface name */ struct in6_addr ifi_lladdr; /* link-local address */ int ifi_ifindex; /* interface index */ UNION_LIST ifi_dhcpv6; /* DHCPv6 addresses */ pid_t ifi_pid; /* DHCPv6 procedd ID */ u_int16_t ifi_dh6:1, /* if DHCPv6 is running */ rsvd:15; }; typedef struct if_info IF_INFO; /* interface structure */ #define ifi_ifname(ifi) ((ifi)->ifi_name) #define ifi_ifindex(ifi) ((ifi)->ifi_ifindex) #define ifi_lladdr(ifi) &((ifi)->ifi_lladdr) extern void init_ifi_table( void ); extern int get_ifi_table( void ); extern struct if_info * seek_ifi_byname(char *, int); extern struct if_info * seek_ifi_byindex(int); extern struct if_info * seek_ifi_bypid(pid_t); extern int if_info_kernel_set ( int, char *, int, int ); extern int if_info_kernel_get ( int, char *, int, int * ); extern void print_ifi_table( void ); extern void ifi_kill_dhcpv6( void ); #endif /* __ND6_IF_H */ dhcpv6-1.0/netbsd.h010060000015740003721000000015540625233634300144270ustar00yunzhouip00000400000004#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include dhcpv6-1.0/parse.c010060000015740003721000000132710625233634300142540ustar00yunzhouip00000400000004/* * parse.c Parsing Routines for DHCPv6 Configuration Files * * Version: @(#)parse.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_adm.h" #include "parse.h" char *prev_line; char *curr_line; static char line[2][MAX_LINE_LEN]; static int ln_pos; static int ln_num; static inline int psdeo_line( int lno ) { return( lno % 2 ); } static int parse_getchar( FILE *f ) { int c = getc(f); if (c == '\n') { prev_line = line[psdeo_line(ln_num)]; curr_line = line[psdeo_line(++ln_num)]; ln_pos = 0; curr_line[0] = 0; } else if (c != EOF) { if (ln_pos < MAX_LINE_LEN ) { curr_line[ln_pos] = c; curr_line[ln_pos+1] = 0; } ln_pos++; } return c; } static inline void skip_to_eol( FILE *f ) { int c; while ( (c=parse_getchar(f)) != EOF ) { if (c == '\n') return; } } /* * a string is identified by "..." */ static int extract_string( FILE *f, char *buf ) { int i, c; int continued = 0; for (i = 0; i < MAX_TOKEN_LEN; i++) { c = parse_getchar(f); if (c == EOF) { log_warn("eof in string token"); break; } if (continued) { continued = 0; buf[i] = c; } else if (c == '\\') continued = 1; else if (c == '"') break; else buf[i] = c; } if (i == MAX_TOKEN_LEN) { log_warn("string token too long"); --i; } buf[i] = 0; return STRING; } static int extract_number( int first, FILE *f, char *buf ) { int xflag = 0; int i=0, c; int type = DIGIT; buf[i++] = first; for (; i < MAX_TOKEN_LEN; i++) { c = parse_getchar(f); if ( isascii(c) && isspace(c) ) break; else if (!xflag && (c == 'x' || c == 'X')) { /* allow one 'x' only, such as 0x3d */ xflag = 1; type |= XPREFIX; } else if (isascii(c) && !isxdigit(c) && (c == '-' || c == '_' || isalpha (c))) { type |= _ALPHA; } else if ( isdigit(c) ) { type |= DIGIT; } else if (isascii(c) && isxdigit(c)) { type |= XDIGIT; } else if (!isascii(c) || !isxdigit(c)) { type |= UNKNOWN; break; } buf[i] = c; } if (i == MAX_TOKEN_LEN) { log_warn("numeric token too long"); --i; } else ungetc(c, f); buf[i] = 0; return type; } static int extract_identifier( int first, FILE *f, char *buf ) { int i = 0, c; int type = NONE; buf [i++] = first; for (; i < MAX_TOKEN_LEN; i++) { c = parse_getchar(f); if ( isascii(c) && isspace(c) ) break; if (!isascii(c) || (c != '-' && c != '_' && !isalnum (c))) { ungetc(c, f); type |= UNKNOWN; break; } if (isdigit(c)) type |= DIGIT; else if (isxdigit(c)) type |= XDIGIT; else if (isascii(c)) type |= _ASCII; else if (isalpha(c)) type |= _ALPHA; buf[i] = c; } if (i == MAX_TOKEN_LEN) { log_warn("token too long"); --i; } else ungetc(c, f); buf[i] = 0; return seek_match(buf, type); } void parse_init( void ) { ln_pos = 0; ln_num = 0; curr_line = line[0]; prev_line = line[1]; curr_line[0] = prev_line[0] = 0; } int get_next_token( FILE *f, char *buf ) { int c; int type = NONE; do { c = parse_getchar(f); if (isascii(c) && isspace(c)) continue; if (c == '#') { skip_to_eol(f); continue; } if (c == '"') { type = extract_string(f, buf); break; } if ((isascii(c) && isdigit(c)) || c == '-') { type = extract_number(c, f, buf); break; } else if (isascii(c) && isalpha(c)) { type = extract_identifier(c, f, buf); break; } else { type = c; break; } } while (1); #ifdef DH6_DEBUG if ( look_db_more() ) log_info("type = %04X or %d, buf = %s", type, type, buf); #endif return type; } int seek_identifer( int type, FILE *f ) { char buf[100]; int type2; rewind(f); parse_init(); do { type2 = get_next_token(f, buf); if (type2 == type) return type; } while (type2 != EOF); return EOF; } int fcopy_until(int type, FILE *to, FILE *from) { int c; char buf[100]; int type2; #ifdef DH6_DEBUG if ( look_db_more() ) log_info("fcopy_until()"); #endif for (;;) { c = parse_getchar(from); if (c == EOF) break; if ( isspace(c)) { fputc(c, to); continue; } if (c == '#') { fputc('#', to); fgets(buf, MAX_LINE_LEN, from); fputs(buf, to); continue; } if (c == '"') { extract_string(from, buf); fprintf(to, "\"%s\"", buf); #ifdef DH6_DEBUG if ( look_db_more() ) log_info("buf:%s", buf); #endif continue; } if ((isascii(c) && isdigit(c)) || c == '-') { extract_number(c, from, buf); fprintf(to, "%s", buf); #ifdef DH6_DEBUG if ( look_db_more() ) log_info("buf:%s", buf); #endif continue; } else if (isascii(c) && isalpha(c)) { type2 = extract_identifier(c, from, buf); if (type2 == type) return type; fprintf(to, "%s", buf); continue; } else { fputc(c, to); continue; } } return EOF; } dhcpv6-1.0/parse.h010060000015740003721000000047240625233634300142640ustar00yunzhouip00000400000004/* * parse.h Tokens in DHCPv6 Configuration Files * * Version: @(#)parse.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __PARSE_H #define __PARSE_H #define MAX_LINE_LEN 101 #define MAX_TOKEN_LEN 2048 #define SEMI ';' #define DOT '.' #define COLON ':' #define COMMA ',' #define SLASH '/' #define LBRACE '{' #define RBRACE '}' #define NONE 0x0000 /* unknow string */ #define UNKNOWN 0x0100 /* unknow string */ #define DIGIT 0x0200 /* 0, 1-9 */ #define XDIGIT 0x0400 /* a-f, A-F */ #define XPREFIX 0x0800 /* 0x, 0X */ #define _ASCII 0x0a00 /* a-z, A-Z */ #define _ALPHA 0x0c00 /* '-', '_', isalpha, !isxdigit */ #define STRING 0x1000 /* "..." */ #define DB_SVR_SERVER 130 #define DB_SVR_LLADDR 131 #define DB_SVR_RELAY 132 #define DB_SVR_CLIENT 133 #define DB_SVR_PRFSIZE 134 #define DB_SVR_TRANS_ID 135 #define DB_SVR_STATE 136 #define DB_SVR_ONLINK 137 #define DB_SVR_PREFER 138 #define DB_SVR_VALID 139 #define DB_CLI_IFNAME 150 #define DB_CLI_SERVER 151 #define DB_CLI_RELAY 152 #define DB_CLI_CLIENT 153 #define DB_CLI_PRFSIZE 154 #define DB_CLI_TRANS_ID 155 #define DB_CLI_STATE 156 #define DB_CLI_REQLIFE 157 #define DB_CLI_PREFER 158 #define DB_CLI_VALID 159 #define SVR_MAX_PREFER_LIFE 170 #define SVR_MAX_VALID_LIFE 171 #define SVR_ADDR_FROM 180 #define SVR_ADDR_TO 181 #define SVR_ADDR_PREFIX 182 #define SVR_MULTICAST_ADDR 183 #define CLI_SOLICIT_PBIT 190 #define CLI_SOLICIT_CBIT 191 #define CLI_REQUEST_LIFE 192 #define CLI_REQUEST_QBIT 193 extern void parse_init( void ); extern int get_next_token( FILE *, char * ); extern int seek_identifer( int type, FILE * ); #endif /* __PARSE_H */ dhcpv6-1.0/rly_conf.c010060000015740003721000000034240625233634300147540ustar00yunzhouip00000400000004/* * rly_conf.c Configuration Routines for Relay Agent * * Version: @(#)rly_conf.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_adm.h" #include "dh6_db.h" #include "parse.h" #include "dh6_if.h" #include "dh6_rly.h" int read_dh6_relay_conf( void ) { char fname[60]; char buf[100]; int type; FILE *f; sprintf(fname, "%s%s", RLY_CONF_PATH, DH6RLY_CONF); if ((f=fopen(fname, "r+")) == NULL) log_sys(2301, "fopen"); rewind(f); parse_init(); do { type = get_next_token(f, buf); switch (type) { default: } } while (type != EOF); fclose(f); return 0; } int seek_match( char *id, int type ) { if ( !isascii(id[0]) ) return type; #ifdef DH6_DEBUG if ( look_db_more() ) log_info("rly_conf: id = %s", id); #endif switch ( tolower(id[0]) ) { case 't': if (!strcasecmp (id, "Test")) return 1; } return type; } dhcpv6-1.0/sock.c010060000015740003721000000162040625233634300141000ustar00yunzhouip00000400000004/* * sock.c DHCPv6 Socket Routines * * Version: @(#)sock.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dh6.h" #include "ext6.h" #include "dh6_if.h" #include "dh6_adm.h" #include "sock.h" /* * How to configure a socket as a multicast? */ /* * Open a UDP socket for an IPv6 client address */ static int udp6_socket( struct in6_addr *addr6, u_int16_t port ) { int s, optval = 1; struct sockaddr_in6 sin6; if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) log_sys(601, "socket"); fcntl(s, F_SETFL, O_NONBLOCK); if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&optval, sizeof(optval)) < 0) log_fatal(602, "SO_REUSEADDR fail"); bzero((char *)&sin6, sizeof(sin6)); /* * u_int8_t sin6_len; * u_int32_t sin6_flowinfo; */ sin6.sin6_family = AF_INET6; if ( addr6 ) memcpy(&sin6.sin6_addr, addr6, sizeof(struct in6_addr)); else memset(&sin6.sin6_addr, 0, sizeof(struct in6_addr)); sin6.sin6_port = htons(port); if (bind(s, (struct sockaddr *)&sin6, sizeof(struct sockaddr_in6))<0) log_sys(603, "bind"); return s; } inline int cli_udp6_socket( struct in6_addr *addr6 ) { return udp6_socket(addr6, DH6_CLIENT_PORT); } inline int rly_udp6_socket( struct in6_addr *addr6 ) { return udp6_socket(addr6, DH6_AGENT_PORT); } inline int svr_udp6_socket( struct in6_addr *addr6 ) { return udp6_socket(addr6, DH6_AGENT_PORT); } char * dh6cli_adm_server_name(char *ifname) { static char name[100]; sprintf(name, "%sdh6_cli_adm.%s", DH6_SERV_PATH, ifname); return name; } char * dh6svr_adm_server_name( void ) { static char name[100]; sprintf(name, "%sdh6_svr_adm", DH6_SERV_PATH); return name; } char * dh6rly_adm_server_name( void ) { static char name[100]; sprintf(name, "%sdh6_rly_adm", DH6_SERV_PATH); return name; } char * dh6cli_adm_name( void ) { static char name[100]; sprintf(name, "%sdh6_cli_adm", DH6_SERV_PATH); return name; } /* * get a UNIX socket */ int open_unix_sock( char *name ) { struct sockaddr_un dmn_addr; int s, dmn_len; unlink( name ); /* in case it was left from last time */ /* * Open a socket (a UNIX domain stream socket). */ if ( (s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) log_sys(604, "socket"); fcntl( s, F_SETFL, O_NONBLOCK); /* * Bind our local address so that the adm_cli can send to us. */ bzero((char *) &dmn_addr, sizeof(dmn_addr)); dmn_addr.sun_family = AF_UNIX; strcpy(dmn_addr.sun_path, name); dmn_len = strlen(dmn_addr.sun_path) + sizeof(dmn_addr.sun_family) + 1; if (bind(s, (struct sockaddr *)&dmn_addr, dmn_len) < 0) log_sys(605, "bind"); listen(s, 5); /* at most 5 messages in queue */ return s; } /* * Close a UDP socket */ void close_unix_sock( int s, char *name ) { if ( s < 0 ) return; close( s ); unlink( name ); } inline int IN6_IS_ADDR_LINKLOCAL(struct in6_addr *sin6) { return ( *((u_int16_t *)sin6) == ntohs(0xFE80) ); } inline int IN6_IS_MULTICAST(struct in6_addr *in6) { return ((in6->s6_addr32[0] & htonl(0xffc00000)) == htonl(0xfe800000)); } int print_sock_bind_info(int s) { struct sockaddr_in6 test_sin; int test_len; getsockname(s, (struct sockaddr *)&test_sin, &test_len); log_info("socket %d bound to address:%s port:%d", s, inet_ntop(AF_INET6, &test_sin.sin6_addr, 16, NULL), ntohs(test_sin.sin6_port) ); return 0; } struct sockaddr_in6 * udp6_dest_addr(char *which, ...) { va_list ap; va_start(ap, which); if ( !strcmp(which, "sock") ) { /* derived from socket */ static struct sockaddr_in6 dest; int s, len; s = va_arg(ap, int); getsockname(s, (struct sockaddr *)&dest, &len); va_end(ap); return &dest; } else if ( !strcmp(which, "msg") ) { /* derived from message */ struct msghdr *msg; struct cmsghdr *cmsg; msg = va_arg(ap, struct msghdr *); cmsg = (struct cmsghdr *)msg->msg_control; if (cmsg->cmsg_level != IPPROTO_IP || cmsg->cmsg_type != IP_RECVDSTADDR) { log_warn(606, "control message type error"); va_end(ap); return NULL; } va_end(ap); return (struct sockaddr_in6 *)CMSG_DATA(cmsg); } else { log_warn(607, "the way of deriving dest_addr not available"); va_end(ap); return NULL; } } void * cmsg_get(struct msghdr *msg, int level, int type) { struct cmsghdr *p; if (msg->msg_controllen <= 0) return NULL; for (p = CMSG_FIRSTHDR(msg); p != NULL; p = CMSG_NXTHDR(msg, p)) { if (p->cmsg_level == level && p->cmsg_type == type) return (void *)CMSG_DATA(p); } return NULL; } void dh6_assign_addr6( char *ifname, /* interface name */ int namelen, /* length of interface name */ struct in6_addr *addr6, /* DHCPv6 address */ int prfsize, /* prefix size */ int status) /* status of the address */ { struct in6_aliasreq addreq6; struct sockaddr_in6 *sin6 = &addreq6.ifra6_addr; int s; if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) log_sys(608, "socket"); memcpy(addreq6.ifra6_name, ifname, namelen); addreq6.ifra6_mask.sin6_len = sizeof(struct sockaddr_in6); inet6_mask(prfsize, &(addreq6.ifra6_mask.sin6_addr)); sin6->sin6_len = sizeof(struct sockaddr_in6); sin6->sin6_family = AF_INET6; memcpy(&sin6->sin6_addr, addr6, IPV6_ADDR_LEN); addreq6.ifra6_status = 0; if ( status == IA6S_PREFERRED) addreq6.ifra6_status |= IA6S_DEPRECATED; if(ioctl(s, SIOCAIFADDR6, (caddr_t)&addreq6) < 0) log_warn(609, "dh6_assign_addr6 SIOCAIFADDR6 fail"); close(s); } void dh6_remove_addr6( char *ifname, /* interface name */ int namelen, /* length of interface name */ struct in6_addr *addr6) /* DHCPv6 address */ { struct in6_ifreq ridreq6; struct sockaddr_in6 *sin6 = &ridreq6.ifr6_addr; int s; if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) log_sys(608, "socket"); memcpy(ridreq6.ifr6_name, ifname, namelen); sin6->sin6_len = sizeof(struct sockaddr_in6); sin6->sin6_family = AF_INET6; memcpy(&sin6->sin6_addr, addr6, IPV6_ADDR_LEN); if(ioctl(s, SIOCDIFADDR6, (caddr_t)&ridreq6) < 0) log_warn(609, "dh6_remove_addr6() SIOCDIFADDR6 fail"); close(s); } dhcpv6-1.0/sock.h010060000015740003721000000031210625233634300140770ustar00yunzhouip00000400000004/* * sock.h External Socket Routines * * Version: @(#)sock.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __DH6_SOCK_H #define __DH6_SOCK_H #define IA6S_PREFERRED 0x20 extern int cli_udp6_socket( struct in6_addr * ); extern int rly_udp6_socket( struct in6_addr * ); extern int svr_udp6_socket( struct in6_addr * ); extern char * dh6cli_adm_server_name(char *); extern char * dh6svr_adm_server_name( void ); extern char * dh6rly_adm_server_name( void ); extern char * dh6cli_adm_name( void ); extern char* inet_ntop(); extern int inet_pton(); extern int IN6_IS_ADDR_LINKLOCAL(struct in6_addr *); extern struct sockaddr_in6 * udp6_dest_addr(char *, ...); extern void * cmsg_get(struct msghdr *, int, int); extern void dh6_assign_addr6( char *, int, struct in6_addr *, int, int); #endif /* __DH6_SOCK_H */ dhcpv6-1.0/su_cli.c010060000015740003721000000200000625233634300144040ustar00yunzhouip00000400000004/* * su_cli.c DHCPv6 Client Super Daemon * * Version: @(#)su_cli.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "localdefs.h" #include "u_timer.h" #include "dispatch.h" #include "u_buf.h" #include "dh6.h" #include "ext6.h" #include "dh6_if.h" #include "dh6_cli.h" #include "dh6_adm.h" #include "sock.h" extern void su_run_unix_server( void * ); extern void su_icmp_msgrcv( void * ); extern void su_adm_msgrcv( void * ); int debug = 0; struct fd_list icmp_sock, unix_sock; struct poll_list poll_unix; int quit_flag = 0; extern UNION_LIST ifi_table; static inline u_int8_t rtadv_managed_bit(struct icmpv6 *icmp_hdr) { return (icmp_hdr->icmp6_hun.ih6_rtad.irta_aflg & 0x80) >> 7; } static inline u_int8_t rtadv_other_bit(struct icmpv6 *icmp_hdr) { return (icmp_hdr->icmp6_hun.ih6_rtad.irta_aflg & 0x40) >> 6; } main(int argc, char *argv[]) { int optval; char op; #ifdef ICMPV6_FILTER struct icmp6_filter icm6f; #endif opterr = 0; while ((op = getopt(argc, argv, "d:D:")) != EOF) { switch (op) { #ifdef DH6_DEBUG case 'd': /* debug */ case 'D': /* debug */ debug = atoi(optarg); break; #endif default: } } if ( daemon_init() < 0 ) log_fatal(1001, "daemon init fail"); if (debug > 0) openlog ("", LOG_CONS, LOG_DAEMON); else openlog (argv[0], 0, LOG_DAEMON); u_free_list_init(); begin_timing(); init_ifi_table(); get_ifi_table(); #ifdef DH6_DEBUG if ( look_cache() ) { log_info("debug = %d", debug); print_ifi_table(); } #endif /* open unix socket; listen for incoming administration commands. */ if ( (unix_sock.fd=open_unix_sock(dh6cli_adm_name())) < 0 ) log_fatal(1002, "open unix socket fail"); init_poll(&poll_unix); poll_unix.data = &unix_sock; poll_unix.function = su_run_unix_server; add_poll(&poll_unix); #ifdef 0 /* very strange "resource temporily unavailable"!!! */ init_fdp(&unix_sock); unix_sock.data = &unix_sock; unix_sock.function = su_run_unix_server; add_fdp(&unix_sock); #endif /* Open a raw ICPMv6 socket */ if ((icmp_sock.fd = socket(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6)) < 0) log_sys(1003, "socket"); optval = 1; if (setsockopt(icmp_sock.fd, IPPROTO_IPV6, IPV6_RXINFO, (char *)&optval, sizeof(optval)) < 0) log_fatal(3006, "IPV6_RXINFO fail"); init_fdp(&icmp_sock); #ifdef ICMPV6_FILTER ICMPV6_FILTER_SETBLOACKALL(&icm6f); ICMPV6_FILTER_SETPASS(ICMPV6_ADVERTISMENT_RT, &icm6f); if (setsockopt(icmp_sock.fd, IPPROTO_ICMPV6, ICMPV6_FILTER, (char *) &icm6f, sizeof(icm6f)) < 0) log_fatal(1005,"ICMPV6_FILTER fail"); #endif init_fdp(&icmp_sock); icmp_sock.data = &icmp_sock; icmp_sock.function = su_icmp_msgrcv; add_fdp(&icmp_sock); for (;;) { dispatch(); if ( quit_flag ) break; } end_timing(); del_poll(&poll_unix); close_unix_sock(unix_sock.fd, dh6cli_adm_name()); del_fdp(&icmp_sock); close(icmp_sock.fd); #ifdef DH6_DEBUG if ( look_xmit() ) log_info("exit from %s", argv[0]); #endif closelog(); exit(0); } void su_run_unix_server( void * data ) { struct fd_list *p = (struct fd_list *)data, *fdp; int fd; struct sockaddr_un unix_addr; int unix_len = sizeof(unix_addr); for (;;) { fd = accept(p->fd, (struct sockaddr *)&unix_addr, &unix_len); if (fd < 0) { if ( errno!=EWOULDBLOCK ) log_sys(1006, "accept"); else return; /* no more pending connections */ } else { if ( (fdp=malloc(sizeof(struct fd_list))) == NULL ) log_sys(1007, "malloc"); init_fdp(fdp); fdp->fd = fd; fdp->data = fdp; fdp->function = su_adm_msgrcv; add_fdp(fdp); } } } void su_adm_msgrcv( void * data ) { struct fd_list *p = (struct fd_list *)data; struct if_info *ifi; ADM_MESSAGE msg; int ret; for (;;) { ret = recv(p->fd, (char*)&msg, MAX_MSG_LEN, 0); if ( ret==0 ) return; else if (ret < 0) { if (errno == EINTR) continue; else log_sys(1008, "recv"); } #ifdef DH6_DEBUG if ( look_xmit() ) log_info("receiving a message from dh6scc"); #endif if ( msg.cmd==ADM_CMD_STOP ) { ifi_kill_dhcpv6(); quit_flag = 1; break; } if (msg.cmd == ADM_OPEN_DHCPV6) { ifi = seek_ifi_byname(msg.un.data, msg.len); if (ifi == NULL) { log_warn(1009,"unknown interface"); continue; } open_dhcpv6(ifi); continue; } log_warn(1011,"unknown command %u", msg.cmd); } close(p->fd); p->fd=-1; del_fdp(p); free(p); } static void exit_dhcpv6_proc( pid_t pid ) { struct if_info *ifi = seek_ifi_bypid(pid); if (ifi != NULL) ifi->ifi_dh6 = 0; } void su_icmp_msgrcv( void * data ) { struct fd_list *p = (struct fd_list *)data; struct iovec aiov[1]; struct msghdr msg; struct cmsghdr *cmsg; struct sockaddr_in6 sin6; struct icmpv6 *icmp_hdr; struct if_info *ifi; u_long len; u_int8_t ctrldata[512]; u_int8_t packet[1024]; struct in6_pktinfo *pktinfo; msg.msg_name = (caddr_t)&sin6; msg.msg_namelen = sizeof(struct sockaddr_in6) ; msg.msg_iov = aiov; msg.msg_iovlen = 1; aiov[0].iov_base = packet; aiov[0].iov_len = sizeof(packet); msg.msg_control = ctrldata; msg.msg_controllen = sizeof(ctrldata); msg.msg_flags = 0; if ((len = recvmsg(p->fd, &msg, 0)) < 0) log_sys(1012, "recvmsg"); cmsg = (struct cmsghdr *)ctrldata; if ((pktinfo=cmsg_get(&msg, IPPROTO_IPV6, IPV6_RXINFO)) == NULL) { log_warn(1012, "IPV6_RXINFO not found"); return; } if ( (ifi=seek_ifi_byindex(pktinfo->ipi6_ifindex)) == NULL ) { log_warn(1013, "interface not found"); return; } icmp_hdr = (struct icmpv6 *)(packet + sizeof(struct ipv6)); if (!ICMPV6_INFOTYPE(icmp_hdr->icmp6_type)) return; if (icmp_hdr->icmp6_type = ICMPV6_ADVERTISMENT_RT) { pid_t pid; #ifdef DH6_DEBUG if ( look_tm() ) { log_info("Receiving Router Advertisement"); log_info("Mbit: %u, Obit: %u", rtadv_managed_bit(icmp_hdr), rtadv_other_bit(icmp_hdr)); /* log_info("Quaizar, r u busy?"); log_info("Don't work too much"); */ } #endif if ( (rtadv_managed_bit(icmp_hdr) || rtadv_other_bit(icmp_hdr)) && !ifi->ifi_dh6 ) open_dhcpv6(ifi); } } int open_dhcpv6(struct if_info *ifi) { pid_t pid; ifi->ifi_dh6 = 1; end_timing(); signal(SIGCHLD, exit_dhcpv6_proc); if ( (pid=fork()) < 0 ) log_sys(1013, "fork"); else if ( pid==0 ) { #ifdef 0 /* this descriptor is not queued to dispatch queue */ del_fdp(&unix_sock); clean_fd_list(); begin_timing(); #endif close(unix_sock.fd); dh6_client_main( ifi->ifi_ifindex ); } ifi->ifi_pid = pid; begin_timing(); return 0; } dhcpv6-1.0/su_clicmd.c010060000015740003721000000057670625233634300151170ustar00yunzhouip00000400000004/* * su_clicmd.c * * errors 1200 - 1299 */ #include "dh6all.h" #include "localdefs.h" #include "u_timer.h" #include "dispatch.h" #include "u_buf.h" #include "dh6.h" #include "ext6.h" #include "nd6_if.h" #include "dh6_cli.h" #include "dh6_adm.h" #include "sock.h" extern char *optarg; extern int optind, opterr, optopt; int debug = 0; /* * Generate an error message with the printf facility. */ void p_error (int err, const char *ctl, ...) { char buf[1000]; va_list list; va_start (list,ctl); vsprintf (buf,ctl,list); printf("error %d: %s\n", err, buf); } main( int argc, char * argv[] ) { u_int8_t buf[MAX_MSG_LEN]; DH6_MESSAGE *msg=(DH6_MESSAGE *)buf; struct sockaddr_un serv_addr; int sockfd, servlen, msglen; if ( argc<2 ) scmd_usage(); if ( strcmp(argv[1],"start")==0 ) { system("dh6cd"); exit(0); } else if ( strcmp(argv[1],"restart")==0 ) { char cmd[50]; sprintf(cmd, "%s stop", argv[0]); system(cmd); sleep(1); sprintf(cmd, "%s start", argv[0]); system(cmd); exit(0); } else if ( strcmp(argv[1],"open")!=0 && strcmp(argv[1],"close")!=0 && strcmp(argv[1],"stop")!=0 ) scmd_usage(); /* * Fill in the structure "serv_addr" with the address of the * mip server that we want to send to. */ bzero((char *) &serv_addr, sizeof(serv_addr)); serv_addr.sun_family = AF_UNIX; strcpy(serv_addr.sun_path, dh6cli_adm_name()); servlen = strlen(serv_addr.sun_path) + sizeof(serv_addr.sun_family) + 1; /* * Open a socket (an UNIX domain stream socket). */ if ( (sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) p_error(1301, strerror(errno)); /* * Connect to the server. */ if (connect(sockfd, (struct sockaddr *) &serv_addr, servlen) < 0) p_error(1302, strerror(errno)); memset(buf, 0, MAX_MSG_LEN); if ( strcmp(argv[1],"open")==0 ) { msg->adm.type = ADM_COMMAND; msg->adm.cmd = ADM_OPEN_DHCPV6; msg->cmd_nm.len = strlen(argv[2]); strcpy(msg->cmd_nm.name, argv[2]); msglen = 3 + msg->cmd_nm.len; scmd_sendto_serv( sockfd, msg, msglen ); goto out; } if ( strcmp(argv[1],"close")==0 ) { msg->adm.type = ADM_COMMAND; msg->adm.cmd = ADM_CLOSE_DHCPV6; msg->cmd_nm.len = strlen(argv[2]); strcpy(msg->cmd_nm.name, argv[2]); msglen = 3 + msg->cmd_nm.len; scmd_sendto_serv( sockfd, msg, msglen ); goto out; } if ( strcmp(argv[1],"stop")==0 ) { msg->adm.type = ADM_COMMAND; msg->adm.cmd = ADM_CMD_STOP; msglen = 2; scmd_sendto_serv( sockfd, msg, msglen ); goto out; } out: close(sockfd); exit(0); } scmd_usage( void ) { printf("usage: nd6cd start\n"); printf(" nd6cd restart\n"); printf(" nd6cd stop\n"); printf(" nd6cd open \n"); printf(" nd6cd close \n"); exit(1); } /* * send a message to server */ int scmd_sendto_serv( int sockfd, DH6_MESSAGE *msg, int msglen ) { if ( send(sockfd, msg, msglen, 0) != msglen) { p_error(603, strerror(errno)); return -1; } return 0; } dhcpv6-1.0/svr_assign.c010060000015740003721000000151030625233634300153140ustar00yunzhouip00000400000004/* * svr_assign.c DHCPv6 Server Address Assignment * * Version: @(#)svr_assign.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_adm.h" #include "dh6_db.h" #include "parse.h" #include "dh6_if.h" #include "dh6_svr.h" extern int debug; #ifdef DH6_DB int dh6_any_idle_dh6addr( void ) { FILE *f; char fname[60]; if ( dh6db_any_idle_dh6addr() ) return 1; sprintf(fname, "%s%s", SVR_CONF_PATH, DH6_NEWADDR); if ((f=fopen(fname, "r+")) == NULL) log_sys(3401, "fopen"); #ifdef DH6_DEBUG if ( look_db() ) log_info("dh6_any_idle_dh6addr(): open %s", fname); #endif if (seek_identifer(SVR_ADDR_FROM, f) != EOF) { fclose(f); return 1; } fclose(f); return 0; } static inline void incr_net_int32(u_int32_t *a) { *a = htonl( ntohl(*a)+1 ); } int inet_get_next_addr(struct in6_addr *next_addr) { if (next_addr->s6_addr32[3] != ~0) incr_net_int32(next_addr->s6_addr32+3); else if (next_addr->s6_addr32[2] != ~0) { incr_net_int32(next_addr->s6_addr32+2); next_addr->s6_addr32[3] = 0; } else if (next_addr->s6_addr32[1] != ~0) { incr_net_int32(next_addr->s6_addr32+1); next_addr->s6_addr32[2] = 0; next_addr->s6_addr32[3] = 0; } else if (next_addr->s6_addr32[0] != ~0) { incr_net_int32(next_addr->s6_addr32); next_addr->s6_addr32[1] = 0; next_addr->s6_addr32[2] = 0; next_addr->s6_addr32[3] = 0; } else memset(next_addr, 0, IPV6_ADDR_LEN); #ifdef DH6_DEBUG if ( look_db_more() ) log_info("inet_get_next_addr(): %s", inet_ntop(AF_INET6, next_addr, IPV6_ADDR_LEN, NULL)); #endif return 0; } inline int inet_cmp(struct in6_addr *addr1, struct in6_addr *addr2) { return memcmp(addr1, addr2, IPV6_ADDR_LEN); } int dh6_get_idle_dh6addr( struct svr_client *sc ) { FILE *f, *f2; char fname[60], fname2[64]; char from[100], to[100], buf[100]; struct in6_addr in6from, in6to; int type, result; if ( dh6db_get_idle_dh6addr(sc) ) return 1; sprintf(fname, "%s%s", SVR_CONF_PATH, DH6_NEWADDR); sprintf(fname2, "%s.old", fname); rename(fname, fname2); if ((f=fopen(fname, "w+")) == NULL) log_sys(3402, "fopen %s", fname); if ((f2=fopen(fname2, "r+")) == NULL) log_sys(3403, "fopen %s", fname2); #ifdef DH6_DEBUG if ( look_db() ) { log_info("dh6_get_idle_dh6addr(): open %s", fname); log_info("open %s", fname2); } #endif if (fcopy_until(SVR_ADDR_FROM, f, f2) == EOF) goto _dh6_get_idle_dh6addr_exit; type = get_next_token(f2, from); if ( !(type & STRING) ) goto _dh6_get_idle_dh6addr_exit; type = get_next_token(f2, buf); if (type != SVR_ADDR_TO) goto _dh6_get_idle_dh6addr_exit; type = get_next_token(f2, to); if ( !(type & STRING) ) goto _dh6_get_idle_dh6addr_exit; type = get_next_token(f2, buf); if (type != SVR_ADDR_PREFIX) goto _dh6_get_idle_dh6addr_exit; type = get_next_token(f2, buf); if ((type & 0xff00) != DIGIT) goto _dh6_get_idle_dh6addr_exit; inet_pton(AF_INET6, from, &in6from); inet_pton(AF_INET6, to, &in6to); sc->sc_prfsize = atoi(buf); memcpy(&sc->sc_cliaddr, &in6from, IPV6_ADDR_LEN); if ( (result=inet_cmp(&in6from, &in6to)) != 0) { inet_get_next_addr(&in6from); fprintf(f, "From \"%s\"\n", inet_ntop(AF_INET6, &in6from, IPV6_ADDR_LEN, NULL)); fprintf(f, "To \"%s\"\n", to); fprintf(f, "Prefix %d\n", sc->sc_prfsize); } fcopy_until(EOF, f, f2); fclose(f2); fclose(f); unlink(fname2); return 1; _dh6_get_idle_dh6addr_exit: fclose(f2); fclose(f); unlink(fname); rename(fname2, fname); return 0; } int dh6_get_requested_dh6addr( struct svr_client *sc ) { return dh6db_get_requested_dh6addr(sc); } int dh6_release_dh6addr( struct svr_client *sc ) { return dh6db_release_dh6addr(sc); } #else /* DH6_DB */ static struct addr_pool { u_int8_t inuse; u_int8_t prfsize; char addr[64]; } tmp_addr_pool[] = { {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5e0"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5e1"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5e2"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5e3"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5e4"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5e5"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5e6"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5e7"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5e8"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5e9"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5ea"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5eb"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5ec"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5ed"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5ee"}, {0, 128, "5f02:3000:84b1:7600:0:900:2b39:b5ef"}, {0, 0, ""} }; int dh6_any_idle_dh6addr( void ) { struct addr_pool *p; for (p = tmp_addr_pool; p->addr[0] != 0; p++) { if ( !p->inuse ) return 1; } return 0; } int dh6_get_idle_dh6addr( struct svr_client *sc ) { struct addr_pool *p; for (p = tmp_addr_pool; p->addr[0] != 0; p++) { if ( !p->inuse ) { inet_pton(AF_INET6, p->addr, &sc->sc_cliaddr); sc->sc_prfsize = p->prfsize; p->inuse = 1; return 1; } } return 0; } int dh6_get_requested_dh6addr( struct svr_client *sc ) { static struct in6_addr addr; struct addr_pool *p; for (p = tmp_addr_pool; p->addr[0] != 0; p++) { if ( p->inuse ) continue; inet_pton(AF_INET6, p->addr, &addr); if ( !memcmp(&sc->sc_cliaddr, &addr, IPV6_ADDR_LEN) ) { sc->sc_prfsize = p->prfsize; p->inuse = 1; return 1; } } return 0; } int dh6_release_dh6addr( struct svr_client *sc ) { static struct in6_addr addr; struct addr_pool *p; for (p = tmp_addr_pool; p->addr[0] != 0; p++) { if ( !p->inuse ) continue; inet_pton(AF_INET6, p->addr, &addr); if ( !memcmp(&sc->sc_cliaddr, &addr, IPV6_ADDR_LEN) ) { p->inuse = 0; return 1; } } return 0; } #endif /* DH6_DB */ return 1; } fclose(f); return 0; } static inline void incr_net_int32(u_int32_t *a) { *a = htonl( ntohl(*a)+1 ); } int inet_get_next_addr(struct in6_addr *next_addr) { if (next_addr->s6_addr32[3] != ~0) incr_net_int32(next_addr->s6_addr32+3); else if (next_addr->s6_addr32[2] != ~0) { incr_net_int32(next_addr->s6_addr32+2); next_addr->s6_addr32[3] = 0; } else if (next_addr->s6_addr32[1] != ~0) { incr_net_int32(next_addr->s6dhcpv6-1.0/svr_conf.c010060000015740003721000000055030625233634300147600ustar00yunzhouip00000400000004/* * svr_conf.c DHCPv6 Server Configuration Routines * * Version: @(#)svr_conf.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_adm.h" #include "dh6_db.h" #include "parse.h" #include "dh6_if.h" #include "dh6_svr.h" extern int MaxPreferLife; extern int MaxValidLife; extern struct in6_addr MulticastAddr; int read_dh6_server_conf( void ) { char fname[60]; char buf[100]; int type; FILE *f; sprintf(fname, "%s%s", SVR_CONF_PATH, DH6SVR_CONF); if ((f=fopen(fname, "r+")) == NULL) log_sys(3301, "fopen"); rewind(f); parse_init(); do { type = get_next_token(f, buf); switch (type) { case SVR_MAX_PREFER_LIFE: type = get_next_token(f, buf); if (type & DIGIT) { MaxPreferLife = atoi(buf); continue; } log_warn(3302, "incorrect MaxPreferLife format"); break; case SVR_MAX_VALID_LIFE: type = get_next_token(f, buf); if (type & DIGIT) { MaxValidLife = atoi(buf); continue; } log_warn(3303, "incorrect MaxValidLife format"); break; case SVR_MULTICAST_ADDR: type = get_next_token(f, buf); if (type & STRING) { inet_pton(AF_INET6, buf, &MulticastAddr); continue; } log_warn(3304, "incorrect MULTICAST_ADDR format"); break; } } while (type != EOF); fclose(f); return 0; } int seek_match( char *id, int type ) { if ( !isascii(id[0]) ) return type; #ifdef DH6_DEBUG if ( look_db_more() ) log_info("svr_conf: id = %s", id); #endif switch ( tolower(id[0]) ) { case 'm': if (!strcasecmp (id, "MaxPreferLife")) return SVR_MAX_PREFER_LIFE; if (!strcasecmp (id, "MaxValidLife")) return SVR_MAX_VALID_LIFE; if (!strcasecmp (id, "MulticastAddr")) return SVR_MULTICAST_ADDR; case 'f': if (!strcasecmp (id, "From")) return SVR_ADDR_FROM; case 't': if (!strcasecmp (id, "To")) return SVR_ADDR_TO; case 'p': if (!strcasecmp (id, "Prefix")) return SVR_ADDR_PREFIX; } return type; } dhcpv6-1.0/svr_db.c010060000015740003721000000167110625233634300144230ustar00yunzhouip00000400000004/* * svr_db.c Database Routines for DHCPv6 Server * * Version: @(#)svr_db.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_adm.h" #include "dh6_db.h" #include "parse.h" #include "dh6_if.h" #include "dh6_svr.h" /* * Be careful!!! The length of a key should be multiple of 16! */ int dh6db_alloc_key(DBT *key, void *entry) { struct svr_client *sc = entry; key->size = 2*IPV6_ADDR_LEN; key->data = malloc(key->size); dh6db_copy(key->data, &sc->sc_lladdr, IPV6_ADDR_LEN); dh6db_copy(((u_int8_t *)key->data)+IPV6_ADDR_LEN, &sc->sc_rlyaddr, IPV6_ADDR_LEN); } int dh6db_alloc_rec(DBT *rec, void *entry) { struct svr_client *sc = entry; struct svr_record *srec; struct timeval tv; rec->size = sizeof(struct svr_record); rec->data = malloc(rec->size); srec = rec->data; dh6db_copy(&srec->svraddr, &sc->sc_sia->sia_addr, IPV6_ADDR_LEN); /* * Very dependent on structures of * struct svr_client and struct svr_record !!! */ dh6db_copy(&srec->lladdr, &sc->sc_lladdr, sizeof(struct svr_record) - IPV6_ADDR_LEN); gettimeofday(&tv,NULL); srec->prefer_life = srec->prefer_life*DH6_LIFETIME_UNIT + tv.tv_sec; srec->valid_life = srec->valid_life*DH6_LIFETIME_UNIT + tv.tv_sec; } int dh6db_convert_rec(DBT *rec, void *entry) { struct svr_client *sc = entry; struct svr_record *srec = rec->data; struct timeval tv; if (rec->data == NULL || rec->size == 0) { log_warn(3213, "Record is NULL"); return -1; } if ((sc->sc_sia=sia_get(&srec->svraddr)) == NULL) { log_warn(3214, "Server address not on list"); return -1; } /* * Very dependent on structures of * struct svr_client and struct svr_record !!! */ dh6db_copy(&sc->sc_lladdr, &srec->lladdr, sizeof(struct svr_record) - IPV6_ADDR_LEN); gettimeofday(&tv,NULL); sc->sc_prefer_life = (sc->sc_prefer_life - tv.tv_sec) / DH6_LIFETIME_UNIT; sc->sc_valid_life = (sc->sc_valid_life - tv.tv_sec) / DH6_LIFETIME_UNIT; } int dh6db_any_idle_dh6addr( void ) { DB *db2; DBT key, rec; #ifdef DH6_DEBUG if ( look_db() ) log_info("dh6db_any_idle_dh6addr()"); #endif if ( (db2=dh6db_open(DH6_SVR_INVAL)) == NULL) log_sys(3215, "dbopen error"); memset(&key, 0, sizeof(key)); key.size = KPREFIX_LEN; key.data = &key_prefix; db2->seq(db2, &key, &rec, R_CURSOR); if (rec.size == sizeof(struct svr_record)) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("database not empty"); #endif dh6db_close(db2); return 1; } dh6db_close(db2); return 0; } int dh6db_get_idle_dh6addr( struct svr_client *sc ) { DB *db2; DBT key, rec; #ifdef DH6_DEBUG if ( look_db() ) log_info("dh6db_get_idle_dh6addr()"); #endif if ( (db2=dh6db_open(DH6_SVR_INVAL)) == NULL) log_sys(3216, "dbopen error"); memset(&key, 0, sizeof(key)); key.size = KPREFIX_LEN; key.data = &key_prefix; db2->seq(db2, &key, &rec, R_CURSOR); if (rec.size == sizeof(struct svr_record)) { db2->del(db2, &key, R_CURSOR); dh6db_convert_rec(&rec, sc); dh6db_close(db2); return 1; } dh6db_close(db2); return 0; } int dh6db_get_requested_dh6addr( struct svr_client *sc ) { DB *db2; #ifdef DH6_DEBUG if ( look_db() ) log_info("dh6db_get_requested_dh6addr()"); #endif if ( (db2=dh6db_open(DH6_SVR_INVAL)) == NULL) log_sys(3217, "dbopen error"); if (dh6db_locate(db2, sc) == 0) { dh6db_del(db2, sc, R_CURSOR); dh6db_close(db2); return 1; } dh6db_close(db2); return 0; } int dh6db_release_dh6addr( struct svr_client *sc ) { DB *db, *db2; int ret = 0; #ifdef DH6_DEBUG if ( look_db() ) log_info("dh6db_release_dh6addr()"); #endif if ( (db2=dh6db_open(DH6_SVR_INVAL)) == NULL) log_sys(3218, "dbopen error"); dh6db_put(db2, sc, R_NOOVERWRITE); dh6db_sync(db2); dh6db_close(db2); if ( (db=dh6db_open(DH6_SVR_INUSE)) == NULL) log_sys(3219, "dbopen error"); if (dh6db_locate(db, sc) == 0) { dh6db_del(db, sc, R_CURSOR); ret = 1; } dh6db_close(db); return ret; } int dh6db_load_sc(struct svr_ifaddr *sia, struct in6_addr *lladdr, struct in6_addr *relay) { DB *db; DBT rec, key; int ret = 0; struct svr_client *sc; if ( sc_get(sia,lladdr,relay) ) return 0; key.size = 2*IPV6_ADDR_LEN; key.data = malloc(key.size); dh6db_copy(key.data, lladdr, IPV6_ADDR_LEN); dh6db_copy(((u_int8_t *)key.data)+IPV6_ADDR_LEN, relay, IPV6_ADDR_LEN); if ( (db=dh6db_open(DH6_SVR_INUSE)) == NULL) log_sys(3220, "dbopen error"); ret = db->get(db, &key, &rec, 0); dh6db_close(db); free(key.data); if (ret == 0 && rec.size > 0) { #ifdef DH6_DEBUG if ( look_db_more() ) log_info("load a record (size %d) to memory", rec.size); #endif if ( (sc=sc_create()) == NULL ) return -1; dh6db_convert_rec(&rec, sc); u_queue_head(&sia->sia_clilist, sc); return 0; } else return -1; } int svr_print_record(struct svr_record *rec) { log_info("DB record: "); log_info(" server: %s", inet_ntop(AF_INET6, &rec->svraddr, 16, NULL)); log_info(" lladdr: %s", inet_ntop(AF_INET6, &rec->lladdr, 16, NULL)); log_info(" agent: %s", inet_ntop(AF_INET6, &rec->rlyaddr, 16, NULL)); log_info(" client: %s", inet_ntop(AF_INET6, &rec->cliaddr, 16, NULL)); log_info(" id:%d, prefix:%d, state:%d, prefer:%ld, valid:%ld", rec->id, rec->prfsize, rec->state, rec->prefer_life, rec->valid_life); } int svr_dbshow_adm( ADM_MESSAGE *msg, int len ) { DB *db; DBT key, rec; struct svr_record srec; /* at the moment just show all the records */ log_info("Server DB %s:", DH6_SVR_INUSE); if ( (db=dh6db_open(DH6_SVR_INUSE)) == NULL) log_sys(1501, "dbopen error"); memset(&key, 0, sizeof(key)); key.size = KPREFIX_LEN; key.data = &key_prefix; db->seq(db, &key, &rec, R_CURSOR); do { if (rec.size < sizeof(struct svr_record)) break; dh6db_copy(&srec, rec.data, sizeof(struct svr_record)); svr_print_record(&srec); } while (db->seq(db, &key, &rec, R_NEXT) == 0); dh6db_close(db); log_info("Server DB %s:", DH6_SVR_INVAL); if ( (db=dh6db_open(DH6_SVR_INVAL)) == NULL) log_sys(1501, "dbopen error"); memset(&key, 0, sizeof(key)); key.size = KPREFIX_LEN; key.data = &key_prefix; db->seq(db, &key, &rec, R_CURSOR); do { if (rec.size < sizeof(struct svr_record)) break; dh6db_copy(&srec, rec.data, sizeof(struct svr_record)); svr_print_record(&srec); } while (db->seq(db, &key, &rec, R_NEXT) == 0); dh6db_close(db); return 0; } svr_client *sc ) { DB *db2; DBT key, rec; #ifdef DHdhcpv6-1.0/u_buf.c010060000015740003721000000137720625233634300142500ustar00yunzhouip00000400000004/* * u_buf.c DHCPv6 Buffering * * Version: @(#)u_buf.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" #include "localdefs.h" #include "u_timer.h" #include "u_buf.h" #include "dispatch.h" #include "dh6.h" #include "ext6.h" #include "dh6_if.h" #include "dh6_cli.h" #include "dh6_adm.h" #define CHAIN_PTR(p) ((struct chain *)p) #define LARGE_CHAIN_PTR(p) ((struct large_chain *)p) /* * table buffer list */ static struct chain u_buf_base[MAX_TABLES]; static struct large_chain u_large_buf_base[MAX_LARGE_TABLES]; UNION_LIST u_free_list; UNION_LIST u_large_free_list; int u_free_list_init( void ) { int i; struct chain *p = (struct chain *)u_buf_base; p[0].prev = NULL; for (i=0; iprev; if ( u_free_list.chain.tail==NULL ) u_free_list.chain.head = NULL; else u_free_list.chain.tail->next = NULL; memset(node, 0, sizeof(struct chain)); return (void *)node; } /* * free a chain node */ void u_free_node( void * node ) { CHAIN_PTR(node)->prev = u_free_list.chain.tail; CHAIN_PTR(node)->next = NULL; if ( u_free_list.chain.head==NULL ) u_free_list.chain.head = CHAIN_PTR(node); else u_free_list.chain.tail->next = CHAIN_PTR(node); u_free_list.chain.tail = CHAIN_PTR(node); } /* * allocate a large chain node */ void * u_alloc_large_node( void ) { struct large_chain *node=u_large_free_list.large_chain.tail; if ( node==NULL ) { log_warn(302, "No more buffer in the large free list"); return NULL; } u_large_free_list.large_chain.tail = node->prev; if ( u_large_free_list.large_chain.tail==NULL ) u_large_free_list.large_chain.head = NULL; else u_large_free_list.large_chain.tail->next = NULL; memset(node, 0, sizeof(struct large_chain)); return (void *)node; } /* * free a large chain node */ void u_free_large_node( void * node ) { LARGE_CHAIN_PTR(node)->prev = u_large_free_list.large_chain.tail; LARGE_CHAIN_PTR(node)->next = NULL; if ( u_large_free_list.large_chain.head==NULL ) u_large_free_list.large_chain.head = LARGE_CHAIN_PTR(node); else u_large_free_list.large_chain.tail->next = LARGE_CHAIN_PTR(node); u_large_free_list.large_chain.tail = LARGE_CHAIN_PTR(node); } void * u_clone_node( void *old, int len ) { struct chain *q; if ( (q = u_alloc_node()) == NULL ) return NULL; memcpy(q->__, ((struct chain *)old)->__, (len>MAX_SIZE_TABLE)?MAX_SIZE_TABLE:len); return q; } void * u_clone_large_node( void *old, int len ) { struct large_chain *q; if ( (q = u_alloc_large_node()) == NULL ) return NULL; memcpy(q->____, ((struct large_chain *)old)->____, (len>MAX_SIZE_LARGE_TABLE)?MAX_SIZE_LARGE_TABLE:len); return q; } /* * Append an element to the beginning of a list. */ void u_queue_head(UNION_LIST *q, void *new) { CHAIN_PTR(new)->next = q->chain.head; CHAIN_PTR(new)->prev = NULL; if ( q->chain.tail==NULL ) q->chain.tail = CHAIN_PTR(new); else q->chain.head->prev = CHAIN_PTR(new); q->chain.head = CHAIN_PTR(new); } /* * Insert an element before a chained element in the middle of a list. */ void u_fore_queue_mid(UNION_LIST *q, void *mid, void *new) { CHAIN_PTR(new)->next = CHAIN_PTR(mid); CHAIN_PTR(new)->prev = CHAIN_PTR(mid)->prev; if ( CHAIN_PTR(mid)->prev==NULL ) q->chain.head = CHAIN_PTR(new); else CHAIN_PTR(mid)->prev->next = CHAIN_PTR(new); CHAIN_PTR(mid)->prev = CHAIN_PTR(new); } /* * Insert an element after a chained element in the middle of a list. */ void u_hind_queue_mid(UNION_LIST *q, void *mid, void *new) { CHAIN_PTR(new)->prev = CHAIN_PTR(mid); CHAIN_PTR(new)->next = CHAIN_PTR(mid)->prev; if ( CHAIN_PTR(mid)->next==NULL ) q->chain.tail = CHAIN_PTR(new); else CHAIN_PTR(mid)->next->prev = CHAIN_PTR(new); CHAIN_PTR(mid)->next = CHAIN_PTR(new); } /* * Append an element to the end of a list. */ void u_queue_tail(UNION_LIST *q, void *new) { CHAIN_PTR(new)->prev = q->chain.tail; CHAIN_PTR(new)->next = NULL; if ( q->chain.head==NULL ) q->chain.head = CHAIN_PTR(new); else q->chain.tail->next = CHAIN_PTR(new); q->chain.tail = CHAIN_PTR(new); } /* * Remove an element from a list. Works even without knowing the list it * is sitting on, which can be handy at times. */ void u_unlink(UNION_LIST *q, void *old) { struct chain *save_prev; if ( !CHAIN_PTR(old)->next ) q->chain.tail = CHAIN_PTR(old)->prev; if ( !CHAIN_PTR(old)->prev ) q->chain.head = CHAIN_PTR(old)->next; save_prev = CHAIN_PTR(old)->prev; if ( CHAIN_PTR(old)->prev ) { CHAIN_PTR(old)->prev->next = CHAIN_PTR(old)->next; CHAIN_PTR(old)->prev = NULL; } if ( CHAIN_PTR(old)->next ) { CHAIN_PTR(old)->next->prev = save_prev; CHAIN_PTR(old)->next = NULL; } } dhcpv6-1.0/u_buf.h010060000015740003721000000056470625233634300142570ustar00yunzhouip00000400000004/* * u_buf.h DHCPv6 Buffer Structures * * Version: @(#)u_buf.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __U_BUF_H #define __U_BUF_H struct chain { struct chain *next; struct chain *prev; #define MAX_SIZE_TABLE 256 #define MAX_TABLES 50 u_int8_t __[MAX_SIZE_TABLE-sizeof(void *)*2]; }; struct large_chain { struct large_chain *next; struct large_chain *prev; #define MAX_SIZE_LARGE_TABLE 1024 #define MAX_LARGE_TABLES 5 u_int8_t ____[MAX_SIZE_LARGE_TABLE-sizeof(void *)*2]; }; typedef union { struct { struct chain *head; struct chain *tail; } chain; struct { struct large_chain *head; struct large_chain *tail; } large_chain; struct { struct if_info *head; struct if_info *tail; } ifi; struct { struct cli_relay *head; struct cli_relay *tail; } cr; struct { struct cli_server *head; struct cli_server *tail; } cs; struct { struct cli_ifaddr *head; struct cli_ifaddr *tail; } cia; struct { struct svr_client *head; struct svr_client *tail; } sc; struct { struct svr_ifaddr *head; struct svr_ifaddr *tail; } sia; struct { struct rly_server *head; struct rly_server *tail; } rs; struct { struct rly_ifaddr *head; struct rly_ifaddr *tail; } ria; } UNION_LIST; #define ul_head chain.head #define ull_head large_chain.head #define ifi_head ifi.head #define cr_head cr.head #define cs_head cs.head #define cia_head cia.head #define sc_head sc.head #define sia_head sia.head #define rs_head rs.head #define ria_head ria.head extern void u_queue_head(UNION_LIST *, void *); extern void u_queue_tail(UNION_LIST *, void *); extern void u_fore_queue_mid(UNION_LIST *, void *, void *); extern void u_hind_queue_mid(UNION_LIST *, void *, void *); extern void u_unlink(UNION_LIST *, void *); extern void * u_clone_node( void *, int ); extern void * u_alloc_node( void ); extern void u_free_node( void * ); extern void * u_clone_large_node( void *, int ); extern void * u_alloc_large_node( void ); extern void u_free_large_node( void * ); #endif /* __U_BUF_H */ dhcpv6-1.0/u_timer.c010060000015740003721000000133110625233634300146010ustar00yunzhouip00000400000004/* * u_time.c DHCPv6 Timing * * Version: @(#)u_timer.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include #include #include #include #include "u_timer.h" extern int debug; static long faketime=0; static int timer_table_lock_flag = 0; inline void lock_timer_table( void ) { timer_table_lock_flag = 1; } inline void unlock_timer_table( void ) { timer_table_lock_flag = 0; } inline int timer_table_locked( void ) { return timer_table_lock_flag; } void begin_timing( void ) { struct itimerval itval; itval.it_interval.tv_sec = TIMER_INTERVAL/1000; itval.it_value.tv_sec = TIMER_INTERVAL/1000; itval.it_interval.tv_usec = (TIMER_INTERVAL%1000)*1000; itval.it_value.tv_usec = (TIMER_INTERVAL%1000)*1000; setitimer(ITIMER_REAL, &itval, (struct itimerval *)NULL); signal(SIGALRM, run_timer_table); } void end_timing( void ) { struct itimerval itval; signal(SIGALRM, SIG_IGN); signal(SIGUSR1, SIG_IGN); itval.it_interval.tv_sec = 0; itval.it_value.tv_sec = 0; itval.it_interval.tv_usec = 0; itval.it_value.tv_usec = 0; setitimer(ITIMER_REAL, &itval, (struct itimerval *)NULL); } static struct u_timer timer_head = { &timer_head, &timer_head, ~0, 0, NULL }; int reset_timer_table( void ) { timer_head.prev = &timer_head; timer_head.next = &timer_head; timer_head.expires = ~0; timer_head.data = NULL; timer_head.function = NULL; } void init_timer(struct u_timer * timer) { timer->next = NULL; timer->prev = NULL; } static void add_timer(struct u_timer * timer) { struct u_timer *p; p = &timer_head; do { p = p->next; } while (timer->expires > p->expires); #ifdef DH6_DEBUG if ( look_tm() ) log_info("pid(%d)-add_timer(): %ld", getpid(), timer->expires - faketime); #endif lock_timer_table(); timer->next = p; timer->prev = p->prev; p->prev = timer; timer->prev->next = timer; unlock_timer_table(); } static int del_timer(struct u_timer * timer) { if (timer->next) { struct u_timer * next; #ifdef DH6_DEBUG if ( look_tm() ) log_info("pid(%d)-del_timer(): %ld", getpid(), timer->expires - faketime); #endif if ((next = timer->next) != NULL) { lock_timer_table(); (next->prev = timer->prev)->next = next; timer->next = timer->prev = NULL; unlock_timer_table(); return (timer->expires - faketime); } } return -1; } static struct poll_list poll_head = { &poll_head, &poll_head, 0, NULL }; int reset_poll_list( void ) { poll_head.prev = &poll_head; poll_head.next = &poll_head; poll_head.data = NULL; poll_head.function = NULL; } void init_poll(struct poll_list * pl) { pl->next = NULL; pl->prev = NULL; } /* * add to the tail of the polling list */ void add_poll(struct poll_list * pl) { pl->next = &poll_head; pl->prev = poll_head.prev; poll_head.prev = pl; pl->prev->next = pl; } void del_poll(struct poll_list * pl) { if (pl->next) { struct poll_list * next; if ((next = pl->next) != NULL) { (next->prev = pl->prev)->next = next; pl->next = pl->prev = NULL; return; } } } /* * LOCK YOUR TIMER TABLE: * * When you are handling some other interrupts, you should * ALWAYS lock your timer table. Otherwise, certain important * queue might be crashed if your timeout function does some * critical stuffs related to this queue. */ void run_timer_table( int signo ) { struct u_timer *t; static intvl = 0; #ifdef DH6_DEBUG if ( look_tm_more() ) log_info("pid(%d)-run_timer_table()", getpid()); #endif /* * What will happen if faketime overflows? */ faketime++; if ( (++intvl) >= 1*SECONDS) { struct poll_list *pl; pl = poll_head.next; while (pl != &poll_head) { void (*fn)(void *) = pl->function; void *data = pl->data; fn(data); pl = pl->next; } intvl = 0; } if ( timer_table_locked() ) return; while ((t = timer_head.next) != &timer_head && t->expires <= faketime) { void (*fn)(void *) = t->function; void *data = t->data; lock_timer_table(); t->next->prev = t->prev; t->prev->next = t->next; t->next = t->prev = NULL; unlock_timer_table(); fn(data); } } inline int stop_timer( struct u_timer *t ) { return del_timer( t ); } inline void start_timer(struct u_timer *t, u_int16_t len) { t->expires = faketime+len; add_timer( t ); } inline int restart_timer(struct u_timer *t, u_int16_t len) { int ret = stop_timer(t); start_timer(t,len); return ret; } /* ignore a timeout */ inline void u_ignore( void *data ) { ; } #ifdef NO_PROBLEM /* * Please alway use u_sleep() instead of sleep() * because otherwise your timers won't work. */ inline unsigned u_sleep(unsigned seconds) { unsigned ret=sleep(seconds); signal(SIGALRM, run_timer_table); return ret; } /* * Please alway use u_alarm() instead of alarm() * because otherwise your timers won't work. */ inline unsigned u_alarm(unsigned seconds) { unsigned ret=alarm(seconds); signal(SIGALRM, run_timer_table); return ret; } #endif dhcpv6-1.0/u_timer.h010060000015740003721000000043120625233634300146070ustar00yunzhouip00000400000004/* * u_timer.h DHCPv6 Timer Structures * * Version: @(#)u_timer.h 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #ifndef __U_TIMER_H #define __U_TIMER_H #ifdef MORE_FREQUENT #define TIMER_INTERVAL 100 /* in milli-seconds */ #define SECONDS 10 /* a number of interval in one second */ #define MILLI_SECS 1 /* a number of interval in one milli-second */ #else #define TIMER_INTERVAL 1000 /* in milli-seconds */ #define SECONDS 1 /* a number of interval in one second */ #define MILLI_SECS 1 /* a number of interval in one milli-second */ #endif struct u_timer { struct u_timer *next; struct u_timer *prev; unsigned long expires; void *data; void (*function)(void *); }; struct poll_list { struct poll_list *next; struct poll_list *prev; void *data; void (*function)(void *); }; extern void begin_timing( void ); extern void end_timing( void ); extern void init_timer(struct u_timer *); extern int stop_timer(struct u_timer *); extern void start_timer(struct u_timer *, u_int16_t); extern int restart_timer(struct u_timer *, u_int16_t); extern void run_timer_table( int ); extern void init_poll(struct poll_list *); extern void add_poll(struct poll_list *); extern void del_poll(struct poll_list *); extern void lock_timer_table(void); extern void unlock_timer_table(void); extern int timer_table_locked(void); extern void u_ignore( void * ); #endif /* __U_TIMER_H */ dhcpv6-1.0/utils.c010060000015740003721000000112400625233634300142740ustar00yunzhouip00000400000004/* * utils.c DHCPv6 Utilities * * Version: @(#)utils.c 1.0 Dec-8-96 * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed WITHOUT ANY WARRANTY and even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * * Many thanks to Jim Bound in Digital Equipment Corp. * Appreciate any further work on this release. * * Authors: Yunzhou Li (yunzhou@iol.unh.edu) * */ #include "compat.h" char *pname = NULL; /* caller can set this from argv[0] */ extern int debug; /* * Generate a message */ void log_info(const char *ctl, ...) { char buf[1000]; va_list list; va_start (list,ctl); vsprintf (buf,ctl,list); syslog (LOG_INFO,"%s",buf); va_end(list); } /* * Generate a warning error message without termination */ void log_warn(int err, const char *ctl, ...) { char buf[1000]; va_list list; va_start (list,ctl); vsprintf (buf,ctl,list); syslog (LOG_ERR,"err%d: %s", err, buf); va_end(list); } /* * Generate a fatal error message and terminate */ void log_fatal(int err, const char *ctl, ...) { char buf[1000]; int errno_save; va_list list; va_start (list,ctl); errno_save = errno; /* value caller might want printed */ vsprintf (buf,ctl,list); syslog (LOG_ERR,"err%d: %s (serr%d:%s)", err, buf, errno_save, strerror(errno_save)); va_end(list); exit(1); } /* * Fatal error related to a system call. * Print a message and terminate. */ void log_sys(int err, const char *ctl, ...) { va_list list; int errno_save; char buf[1000]; va_start(list, ctl); errno_save = errno; /* value caller might want printed */ vsprintf(buf, ctl, list); syslog (LOG_ERR, "err%d: %s() - %d:%s", err, buf, errno_save, strerror(errno_save)); va_end(list); exit(2); } /* * Fatal error related to a system call. * Print a message and terminate. */ int log_sys_warn(int err, const char *ctl, ...) { va_list list; int errno_save; char buf[1000]; va_start(list, ctl); errno_save = errno; /* value caller might want printed */ vsprintf(buf, ctl, list); syslog (LOG_ERR, "err%d: %s() - %d:%s", err, buf, errno_save, strerror(errno_save)); va_end(list); } int lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len) { struct flock lock; lock.l_type = type; /* F_RDLCK, F_WRLCK, F_UNLCK */ lock.l_start = offset; /* byte offset, relative to l_whence */ lock.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */ lock.l_len = len; /* #bytes (0 means to EOF) */ return( fcntl(fd, cmd, &lock) ); } int daemon_init( void ) { pid_t pid; if ( (pid=fork()) < 0 ) { log_sys(401, "fork"); return -1; } /* * the top parent process does nothing and exits */ else if ( pid!=0 ) exit(0); setsid(); chdir("/"); umask(0); return 0; } int delay(int k) { int i, j; for (i = 0; i < k; i++) for (j = 0; j < k; i++) ; } int deadloop( void ) { for (;;) ; } char * time_ntop(int lifetime) { static char buf[20]; struct timeval tv; struct tm *t; time_t clock; gettimeofday(&tv,NULL); clock = tv.tv_sec + lifetime; t = gmtime(&clock); sprintf(buf, "%02s-%02s-%02s//%02s:%02s:%02s", t->tm_year, t->tm_mon, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec); return buf; } int time_pton(char *stm) { struct timeval tv; time_t clock; struct tm t; t.tm_year = atoi(stm); t.tm_mon = atoi(stm+3); t.tm_mday = atoi(stm+6); t.tm_hour = atoi(stm+9); t.tm_min = atoi(stm+12); t.tm_sec = atoi(stm+15); clock = mktime(&t); gettimeofday(&tv,NULL); if (clock > tv.tv_sec) return clock - tv.tv_sec; else return 0; } #ifdef DH6_DEBUG #define DEBUG_LEVEL 6 inline look_xmit( void ) { return (debug%DEBUG_LEVEL >= 1); } inline look_xmit_more( void ) { return (debug == DEBUG_LEVEL); } inline look_cache( void ) { return (debug%DEBUG_LEVEL >= 2); } inline look_cache_more( void ) { return (debug == DEBUG_LEVEL+1); } inline look_db( void ) { return (debug%DEBUG_LEVEL >= 3); } inline look_db_more( void ) { return (debug == DEBUG_LEVEL+2); } inline look_dp( void ) { return (debug%DEBUG_LEVEL >= 4); } inline look_dp_more( void ) { return (debug == DEBUG_LEVEL+3); } inline look_tm( void ) { return (debug%DEBUG_LEVEL >= 5); } inline look_tm_more( void ) { return (debug == DEBUG_LEVEL+4); } #endif /* DH6_DEBUG */