discover.c

Go to the documentation of this file.
00001 /*
00002  * Copyright (C) 2001-2005 by egnite Software GmbH. All rights reserved.
00003  *
00004  * Redistribution and use in source and binary forms, with or without
00005  * modification, are permitted provided that the following conditions
00006  * are met:
00007  *
00008  * 1. Redistributions of source code must retain the above copyright
00009  *    notice, this list of conditions and the following disclaimer.
00010  * 2. Redistributions in binary form must reproduce the above copyright
00011  *    notice, this list of conditions and the following disclaimer in the
00012  *    documentation and/or other materials provided with the distribution.
00013  * 3. Neither the name of the copyright holders nor the names of
00014  *    contributors may be used to endorse or promote products derived
00015  *    from this software without specific prior written permission.
00016  *
00017  * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
00018  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00019  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
00020  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EGNITE
00021  * SOFTWARE GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
00022  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
00023  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
00024  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
00025  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00026  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
00027  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00028  * SUCH DAMAGE.
00029  *
00030  * For additional information see http://www.ethernut.de/
00031  *
00032  */
00033 
00034 /*
00035  * $Log$
00036  * Revision 1.6  2009/02/13 14:52:05  haraldkipp
00037  * Include memdebug.h for heap management debugging support.
00038  *
00039  * Revision 1.5  2009/02/06 15:37:40  haraldkipp
00040  * Added stack space multiplier and addend. Adjusted stack space.
00041  *
00042  * Revision 1.4  2009/01/17 11:26:52  haraldkipp
00043  * Getting rid of two remaining BSD types in favor of stdint.
00044  * Replaced 'u_int' by 'unsinged int' and 'uptr_t' by 'uintptr_t'.
00045  *
00046  * Revision 1.3  2009/01/16 17:03:50  haraldkipp
00047  * Configurable discovery protocol version and port plus
00048  * configurable service thread stack size. The new version 1.1
00049  * allows host names up to 98 characters. Added some code
00050  * to make sure, that nothing is overwritten with version 1.0
00051  * protocol and too long host names. Protocol version 1.0
00052  * is still the default.
00053  *
00054  * Revision 1.2  2008/08/11 07:00:35  haraldkipp
00055  * BSD types replaced by stdint types (feature request #1282721).
00056  *
00057  * Revision 1.1  2006/09/07 09:06:17  haraldkipp
00058  * Discovery service added.
00059  *
00060  */
00061 
00062 #include <sys/confnet.h>
00063 #include <sys/confos.h>
00064 #include <sys/thread.h>
00065 #include <sys/timer.h>
00066 #include <sys/socket.h>
00067 
00068 #include <netinet/in.h>
00069 #include <net/if_var.h>
00070 
00071 #include <stdlib.h>
00072 #include <string.h>
00073 #include <memdebug.h>
00074 
00075 #include <pro/discover.h>
00076 
00081 
00082 #ifndef NUT_THREAD_DISTSTACK
00083 #if defined(__AVR__)
00084 #if defined(__GNUC__)
00085 /* avr-gcc size optimized code uses 124 bytes. */
00086 #define NUT_THREAD_DISTSTACK  224
00087 #else
00088 /* icc-avr v7.19 uses 244 bytes. */
00089 #define NUT_THREAD_DISTSTACK  384
00090 #endif
00091 #else
00092 /* arm-elf-gcc used 232 bytes with size optimized, 476 bytes with debug code. */
00093 #define NUT_THREAD_DISTSTACK  320
00094 #endif
00095 #endif
00096 
00097 #ifndef DISCOVERY_PORT
00098 #define DISCOVERY_PORT  9806
00099 #endif
00100 
00101 typedef struct {
00102     uint32_t disopt_ipmask;
00103     uint16_t disopt_port;
00104     unsigned int disopt_flags;
00105 } DISCOVERY_OPTIONS;
00106 
00107 static DISCOVERY_OPTIONS disopt;
00108 static uint32_t xid;
00109 
00110 static int NutDiscoveryHandler(uint32_t ip, uint16_t port, DISCOVERY_TELE * dist, int len);
00111 static NutDiscoveryCallback discovery_callback = NutDiscoveryHandler;
00112 
00120 int NutDiscoveryAnnTele(DISCOVERY_TELE * dist)
00121 {
00122     memset(dist, 0, sizeof(DISCOVERY_TELE));
00123     dist->dist_xid = xid;
00124     dist->dist_type = DIST_ANNOUNCE;
00125     dist->dist_ver = DISCOVERY_VERSION;
00126     memcpy(dist->dist_mac, confnet.cdn_mac, sizeof(dist->dist_mac));
00127     dist->dist_ip_addr = confnet.cdn_ip_addr;
00128     dist->dist_ip_mask = confnet.cdn_ip_mask;
00129     dist->dist_gateway = confnet.cdn_gateway;
00130     dist->dist_cip_addr = confnet.cdn_cip_addr;
00131 #if DISCOVERY_VERSION <= 0x10
00132     memcpy(dist->dist_hostname, confos.hostname, sizeof(dist->dist_hostname));
00133     return sizeof(DISCOVERY_TELE) - sizeof(dist->dist_custom);
00134 #else
00135     dist->dist_appendix[0] = (uint8_t)strlen(confos.hostname);
00136     memcpy(&dist->dist_appendix[1], confos.hostname, dist->dist_appendix[0]);
00137     return sizeof(DISCOVERY_TELE) - sizeof(dist->dist_appendix) + dist->dist_appendix[0] + 1;
00138 #endif
00139 }
00140 
00148 int NutDiscoveryAppConf(DISCOVERY_TELE * dist)
00149 {
00150     memset(confos.hostname, 0, sizeof(confos.hostname));
00151 #if DISCOVERY_VERSION <= 0x10
00152     strncpy(confos.hostname, (char *)dist->dist_hostname, sizeof(confos.hostname) - 1);
00153 #else
00154     memcpy(confos.hostname, &dist->dist_appendix[1], dist->dist_appendix[0]);
00155 #endif
00156     NutSaveConfig();
00157 
00158     memcpy(confnet.cdn_mac, dist->dist_mac, sizeof(confnet.cdn_mac));
00159     confnet.cdn_ip_addr = dist->dist_ip_addr;
00160     confnet.cdn_ip_mask = dist->dist_ip_mask;
00161     confnet.cdn_gateway = dist->dist_gateway;
00162     confnet.cdn_cip_addr = dist->dist_cip_addr;
00163 
00164     return NutNetSaveConfig();
00165 }
00166 
00167 /*
00168  * \brief Default discovery datagram handler.
00169  *
00170  * \param ip    Sender's IP address.
00171  * \param port  Sender's UDP port.
00172  * \param dtel  Pointer to the UDP telegram buffer.
00173  * \param len   UDP telegram size.
00174  */
00175 static int NutDiscoveryHandler(uint32_t ip, uint16_t port, DISCOVERY_TELE * dist, int len)
00176 {
00177     int rc = -1;
00178 #if DISCOVERY_VERSION <= 0x10
00179     size_t minlen = sizeof(DISCOVERY_TELE) - sizeof(dist->dist_custom);
00180 #else
00181     size_t minlen = sizeof(DISCOVERY_TELE) - sizeof(dist->dist_appendix) + 1;
00182 #endif
00183 
00184     /* Check minimum datagram length. */
00185     if (len >= minlen) {
00186         /* 
00187          * Request telegram. 
00188          */
00189         if (dist->dist_type == DIST_REQUEST) {
00190             /* Respond to requests. */
00191             rc = NutDiscoveryAnnTele(dist);
00192         }
00193 
00194         /* 
00195          * Apply telegram. 
00196          */
00197         else if (dist->dist_type == DIST_APPLY
00198                    /* Check exchange ID. */
00199                    && dist->dist_xid == xid
00200                    /* Required protocol version. */
00201                    && dist->dist_ver == DISCOVERY_VERSION) {    
00202             xid += NutGetTickCount();
00203             /* Store configuration. */
00204             rc = NutDiscoveryAppConf(dist);
00205         }
00206     }
00207     return rc;
00208 }
00209 
00210 THREAD(DiscoveryResponder, arg)
00211 {
00212     UDPSOCKET *sock;
00213     DISCOVERY_TELE *dist;
00214     uint32_t raddr;
00215     uint16_t rport;
00216     int len;
00217 
00218     /* Insist on allocating a datagram buffer. */
00219     while ((dist = malloc(sizeof(DISCOVERY_TELE))) == NULL) {
00220         NutSleep(1000);
00221     }
00222 
00223     /* Insist on creating a socket. */
00224     while ((sock = NutUdpCreateSocket(disopt.disopt_port)) == NULL) {
00225         NutSleep(1000);
00226     }
00227 
00228     /* Nut/Net doesn't provide UDP datagram buffering by default. */
00229     {
00230         uint16_t max_ms = sizeof(DISCOVERY_TELE) * 3;
00231 
00232         NutUdpSetSockOpt(sock, SO_RCVBUF, &max_ms, sizeof(max_ms));
00233     }
00234 
00235     /* Create a pseudo random telegram identifier. */
00236     memcpy(&xid, &confnet.cdn_mac[2], sizeof(xid));
00237     xid += NutGetTickCount();
00238 
00239     /* Optionally send initial announce datagram. */
00240     if (disopt.disopt_flags & DISF_INITAL_ANN) {
00241         /* Variable sleep avoids broadcast storms in large installations. */
00242         NutSleep(500 + (xid & 0x7FF));
00243         if ((len = NutDiscoveryAnnTele(dist)) > 0) {
00244             NutUdpSendTo(sock, INADDR_BROADCAST, disopt.disopt_port, dist, len);
00245         }
00246     }
00247 
00248     /* Handle discovery telegrams in an endless loop. */
00249     for (;;) {
00250         len = NutUdpReceiveFrom(sock, &raddr, &rport, dist, sizeof(DISCOVERY_TELE), 0);
00251         /* Updates may be filtered by an IP mask. */
00252         if ((raddr & disopt.disopt_ipmask) == raddr && len > 0 && discovery_callback) {
00253             if ((len = discovery_callback(raddr, rport, dist, len)) > 0) {
00254                 /* Broadcast response if destination is unreachable. */
00255                 if ((raddr & confnet.cdn_ip_mask) != (confnet.cdn_ip_addr & confnet.cdn_ip_mask)) {
00256                     raddr = INADDR_BROADCAST;
00257                 }
00258                 NutUdpSendTo(sock, raddr, disopt.disopt_port, dist, len);
00259             }
00260         }
00261         /* Avoid system blocking by datagram storms. */
00262         NutSleep(100);
00263     }
00264 }
00265 
00280 NutDiscoveryCallback NutRegisterDiscoveryCallback(NutDiscoveryCallback func)
00281 {
00282     NutDiscoveryCallback rc = discovery_callback;
00283 
00284     discovery_callback = func;
00285 
00286     return rc;
00287 }
00288 
00306 int NutRegisterDiscovery(uint32_t ipmask, uint16_t port, unsigned int flags)
00307 {
00308     static HANDLE tid = NULL;
00309 
00310     if (tid == NULL) {
00311         disopt.disopt_ipmask = ipmask;
00312         disopt.disopt_port = port ? port : DISCOVERY_PORT;
00313         disopt.disopt_flags = flags;
00314         tid = NutThreadCreate("udisc", DiscoveryResponder, NULL, 
00315             (NUT_THREAD_DISTSTACK * NUT_THREAD_STACK_MULT) + NUT_THREAD_STACK_ADD);
00316         if (tid) {
00317             return 0;
00318         }
00319     }
00320     return -1;
00321 }
00322 

© 2000-2007 by egnite Software GmbH - visit http://www.ethernut.de/