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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
net-ip.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：25k
源码类别：

通讯编程

开发平台：

Visual C++

net-ip.cc：源码内容
  1. /*-
  2.  * Copyright (c) 1993-1994, 1998
  3.  * The Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. All advertising materials mentioning features or use of this software
  15.  *    must display the following acknowledgement:
  16.  *      This product includes software developed by the University of
  17.  *      California, Berkeley and the Network Research Group at
  18.  *      Lawrence Berkeley Laboratory.
  19.  * 4. Neither the name of the University nor of the Laboratory may be used
  20.  *    to endorse or promote products derived from this software without
  21.  *    specific prior written permission.
  22.  *
  23.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33.  * SUCH DAMAGE.
  34.  */
  35. #ifndef lint
  36. static const char rcsid[] =
  37.     "@(#) $Header: /cvsroot/nsnam/ns-2/emulate/net-ip.cc,v 1.20 2003/10/12 21:13:09 xuanc Exp $ (LBL)";
  38. #endif
  40. #include <stdio.h>
  41. #ifndef WIN32
  42. #include <unistd.h>
  43. #endif
  44. #include <time.h>
  45. #include <errno.h>
  46. #include <string.h>
  47. #ifdef WIN32
  48. #include <io.h>
  49. #define close closesocket
  50. #else
  51. #include <sys/param.h>
  52. #include <sys/socket.h>
  53. #include <sys/ioctl.h>
  54. #include <netinet/in.h>
  55. #include <netinet/in_systm.h>
  56. #include <netinet/ip.h>
  57. typedef int Socket;
  58. #endif
  59. #if defined(sun) && defined(__svr4__)
  60. #include <sys/systeminfo.h>
  61. #endif
  63. #include "config.h"
  64. #include "net.h"
  65. #include "inet.h"
  66. #include "tclcl.h"
  67. #include "scheduler.h"
  69. //#define NIPDEBUG 1
  70. #ifdef NIPDEBUG
  71. #define NIDEBUG(x) { if (NIPDEBUG) fprintf(stderr, (x)); }
  72. #define NIDEBUG2(x,y) { if (NIPDEBUG) fprintf(stderr, (x), (y)); }
  73. #define NIDEBUG3(x,y,z) { if (NIPDEBUG) fprintf(stderr, (x), (y), (z)); }
  74. #define NIDEBUG4(w,x,y,z) { if (NIPDEBUG) fprintf(stderr, (w), (x), (y), (z)); }
  75. #define NIDEBUG5(v,w,x,y,z) { if (NIPDEBUG) fprintf(stderr, (v), (w), (x), (y), (z)); }
  76. #else
  77. #define NIDEBUG(x) { }
  78. #define NIDEBUG2(x,y) { }
  79. #define NIDEBUG3(x,y,z) { }
  80. #define NIDEBUG4(w,x,y,z) { }
  81. #define NIDEBUG5(v,w,x,y,z) { }
  82. #endif
  85. /*
  86.  * Net-ip.cc: this file defines the IP and IP/UDP network
  87.  * objects.  IP provides a raw IP interface and support functions
  88.  * [such as setting multicast parameters].  IP/UDP provides a standard
  89.  * UDP datagram interface.
  90.  */
  92. //
  93. // IPNetwork: a low-level (raw) IP network object
  94. //
  96. class IPNetwork : public Network {
  97. public:
  98. IPNetwork();
  100.         inline int ttl() const { return (mttl_); } // current mcast ttl
  101. inline int noloopback_broken() { // no loopback filter?
  102. return (noloopback_broken_);
  103. }
  104. int setmttl(Socket, int); // set mcast ttl
  105. int setmloop(Socket, int); // set mcast loopback
  106. int command(int argc, const char*const* argv); // virtual in Network
  107. inline Socket rchannel() { return(rsock_); } // virtual in Network
  108. inline Socket schannel() { return(ssock_); } // virtual in Network
  110.         int send(u_char* buf, int len); // virtual in Network
  111.         int recv(u_char* buf, int len, sockaddr& from, double& ); // virtual in Network
  113.         inline in_addr& laddr() { return (localaddr_); }
  114.         inline in_addr& dstaddr() { return (destaddr_); }
  116. int add_membership(Socket, in_addr& grp); // join mcast
  117. int drop_membership(Socket, in_addr& grp); // leave mcast
  119. /* generally useful routines */
  121. static int bindsock(Socket, in_addr&, u_int16_t, sockaddr_in&);
  122. static int connectsock(Socket, in_addr&, u_int16_t, sockaddr_in&);
  123. static int rbufsize(Socket, int);
  124. static int sbufsize(Socket, int);
  126. protected:
  127. in_addr destaddr_; // remote side, if set (network order)
  128. in_addr localaddr_; // local side (network order)
  129.         int mttl_; // multicast ttl to use
  130. Socket rsock_; // socket to receive on
  131. Socket ssock_; // socket to send on
  132.         int noloopback_broken_; // couldn't turn (off) mcast loopback
  133. int loop_; // do we want loopbacks?
  134. // (system usually assumes yes)
  136. void reset(int reconfigure); // reset + reconfig?
  137. virtual int open(int mode); // open sockets/endpoints
  138. virtual void reconfigure(); // restore state after reset
  139. int close();
  141. time_t last_reset_;
  142. };
  144. class UDPIPNetwork : public IPNetwork {
  145. public:
  146. UDPIPNetwork();
  148. int send(u_char*, int);
  149. int recv(u_char*, int, sockaddr&, double&);
  150. int open(int mode); // mode only
  152. int command(int argc, const char*const* argv);
  153. void reconfigure();
  154. void add_membership(Socket, in_addr&, u_int16_t); // udp version
  155. protected:
  156. int bind(in_addr&, u_int16_t port); // bind to addr/port, mcast ok
  157. int connect(in_addr& remoteaddr, u_int16_t port); // connect()
  158.         u_int16_t lport_; // local port (network order)
  159.         u_int16_t port_; // remote (dst) port (network order)
  160. };
  162. static class IPNetworkClass : public TclClass {
  163.     public:
  164. IPNetworkClass() : TclClass("Network/IP") {}
  165. TclObject* create(int, const char*const*) {
  166. return (new IPNetwork);
  167. }
  168. } nm_ip;
  170. static class UDPIPNetworkClass : public TclClass {
  171.     public:
  172. UDPIPNetworkClass() : TclClass("Network/IP/UDP") {}
  173. TclObject* create(int, const char*const*) {
  174. return (new UDPIPNetwork);
  175. }
  176. } nm_ip_udp;
  178. IPNetwork::IPNetwork() :
  179. mttl_(0),
  180.         rsock_(-1), 
  181.         ssock_(-1),
  182.         noloopback_broken_(0),
  183. loop_(1)
  184. {
  185. localaddr_.s_addr = 0L;
  186. destaddr_.s_addr = 0L;
  187. NIDEBUG("IPNetwork: ctorn");
  188. }
  190. UDPIPNetwork::UDPIPNetwork() :
  191.         lport_(htons(0)), 
  192.         port_(htons(0))
  193. {
  194. NIDEBUG("UDPIPNetwork: ctorn");
  195. }
  197. /*
  198.  * UDPIP::send -- send "len" bytes in buffer "buf" out the sending
  199.  * channel.
  200.  *
  201.  * returns the number of bytes written
  202.  */
  203. int
  204. UDPIPNetwork::send(u_char* buf, int len)
  205. {
  206. int cc = ::send(schannel(), (char*)buf, len, 0);
  207. NIDEBUG5("UDPIPNetwork(%s): ::send(%d, buf, %d) returned %dn",
  208. name(), schannel(), len, cc);
  210. if (cc < 0) {
  211. switch (errno) {
  212. case ECONNREFUSED:
  213. /* no one listening at some site - ignore */
  214. #if defined(__osf__) || defined(_AIX) || defined(__FreeBSD__)
  215. /*
  216.  * Here's an old comment...
  217.  *
  218.  * Due to a bug in kern/uipc_socket.c, on several
  219.  * systems, datagram sockets incorrectly persist
  220.  * in an error state on receipt of an ICMP
  221.  * port-unreachable.  This causes unicast connection
  222.  * rendezvous problems, and worse, multicast
  223.  * transmission problems because several systems
  224.  * incorrectly send port unreachables for 
  225.  * multicast destinations.  Our work around
  226.  * is to simply close and reopen the socket
  227.  * (by calling reset() below).
  228.  *
  229.  * This bug originated at CSRG in Berkeley
  230.  * and was present in the BSD Reno networking
  231.  * code release.  It has since been fixed
  232.  * in 4.4BSD and OSF-3.x.  It is known to remain
  233.  * in AIX-4.1.3.
  234.  *
  235.  * A fix is to change the following lines from
  236.  * kern/uipc_socket.c:
  237.  *
  238.  * if (so_serror)
  239.  * snderr(so->so_error);
  240.  *
  241.  * to:
  242.  *
  243.  * if (so->so_error) {
  244.  *  error = so->so_error;
  245.  * so->so_error = 0;
  246.  * splx(s);
  247.  * goto release;
  248.  * }
  249.  *
  250.  */
  251. reset(1);
  252. #endif
  253. break;
  255. case ENETUNREACH:
  256. case EHOSTUNREACH:
  257. /*
  258.  * These "errors" are totally meaningless.
  259.  * There is some broken host sending
  260.  * icmp unreachables for multicast destinations.
  261.  * UDP probably aborted the send because of them --
  262.  * try exactly once more.  E.g., the send we
  263.  * just did cleared the errno for the previous
  264.  * icmp unreachable, so we should be able to
  265.  * send now.
  266.  */
  267. cc = ::send(schannel(), (char*)buf, len, 0);
  268. break;
  270. default:
  271. fprintf(stderr, "UDPIPNetwork(%s): send failed: %sn",
  272. name(), strerror(errno));
  273. return (-1);
  274. }
  275. }
  276. return cc; // bytes sent
  277. }
  278. int
  279. UDPIPNetwork::recv(u_char* buf, int len, sockaddr& from, double& ts)
  280. {
  281. sockaddr_in sfrom;
  282. int fromlen = sizeof(sfrom);
  283. int cc = ::recvfrom(rsock_, (char*)buf, len, 0,
  284.     (sockaddr*)&sfrom, (socklen_t*)&fromlen);
  285. NIDEBUG5("UDPIPNetwork(%s): ::recvfrom(%d, buf, %d) returned %dn",
  286. name(), rsock_, len, cc);
  287. if (cc < 0) {
  288. if (errno != EWOULDBLOCK) {
  289. fprintf(stderr,
  290. "UDPIPNetwork(%s): recvfrom failed: %sn",
  291. name(), strerror(errno));
  292. }
  293. return (-1);
  294. }
  295. from = *((sockaddr*)&sfrom);
  297. /*
  298.  * if we received multicast data and we don't want the look,
  299.  * there is a chance it is
  300.  * what we sent if "noloopback_broken_" is set.
  301.  * If so, filter out the stuff we don't want right here.
  302.  */
  303.  
  304. if (!loop_ && noloopback_broken_ &&
  305.     sfrom.sin_addr.s_addr == localaddr_.s_addr &&
  306.     sfrom.sin_port == lport_) {
  307. NIDEBUG2("UDPIPNetwork(%s): filtered out our own pktn", name());
  308. return (0); // empty
  309. }
  311. ts = Scheduler::instance().clock();
  312. return (cc); // number of bytes received
  313. }
  315. int
  316. UDPIPNetwork::open(int mode)
  317. {
  318. if (mode == O_RDONLY || mode == O_RDWR) {
  319. rsock_ = socket(AF_INET, SOCK_DGRAM, 0);
  320. if (rsock_ < 0) {
  321. fprintf(stderr,
  322. "UDPIPNetwork(%s): open: couldn't open rcv sockn",
  323. name());
  324. }
  325. nonblock(rsock_);
  326. int on = 1;
  327. if (::setsockopt(rsock_, SOL_SOCKET, SO_REUSEADDR, (char *)&on,
  328. sizeof(on)) < 0) {
  329. fprintf(stderr,
  330. "UDPIPNetwork(%s): open: warning: unable set REUSEADDR: %sn",
  331. name(), strerror(errno));
  332. }
  333. #ifdef SO_REUSEPORT
  334. on = 1;
  335. if (::setsockopt(rsock_, SOL_SOCKET, SO_REUSEPORT, (char *)&on,
  336.        sizeof(on)) < 0) {
  337. fprintf(stderr,
  338. "UDPIPNetwork(%s): open: warning: unable set REUSEPORT: %sn",
  339. name(), strerror(errno));
  340. }
  341. #endif
  342. /*
  343.  * XXX don't need this for the session socket.
  344.  */
  345. if (rbufsize(rsock_, 80*1024) < 0) {
  346. if (rbufsize(rsock_, 32*1024) < 0) {
  347. fprintf(stderr,
  348. "UDPIPNetwork(%s): open: unable to set r bufsize to %d: %sn",
  349. name(), 32*1024, strerror(errno));
  350. }
  351. }
  352. }
  353. if (mode == O_WRONLY || mode == O_RDWR) {
  354. ssock_ = socket(AF_INET, SOCK_DGRAM, 0);
  355. if (ssock_ < 0) {
  356. fprintf(stderr,
  357. "UDPIPNetwork(%s): open: couldn't open snd sockn",
  358. name());
  359. }
  360. nonblock(ssock_);
  361. int firsttry = 80 * 1024;
  362. int secondtry = 48 * 1024;
  364. if (sbufsize(ssock_, firsttry) < 0) {
  365. if (sbufsize(ssock_, secondtry) < 0) {
  366. fprintf(stderr,
  367.   "UDPIPNetwork(%s): open: cannot set send sockbuf size to %d bytes, using defaultn",  
  368. name(), secondtry);
  369. }
  370. }
  372. }
  373. mode_ = mode;
  374. NIDEBUG5("UDPIPNetwork(%s): opened network w/mode %d, ssock:%d, rsock:%dn",
  375. name(), mode_, rsock_, ssock_);
  376. return (0);
  377. }
  379. //
  380. // IP/UDP version of add_membership: try binding
  381. //
  383. void
  384. UDPIPNetwork::add_membership(Socket sock, in_addr& addr, u_int16_t port)
  385. {
  386. int failure = 0;
  387. sockaddr_in sin;
  388. if (bindsock(sock, addr, port, sin) < 0)
  389. failure = 1;
  390. if (failure) {
  391. in_addr addr2 = addr;
  392. addr2.s_addr = INADDR_ANY;
  393. if (bindsock(sock, addr2, port, sin) < 0)
  394. failure = 1;
  395. else
  396. failure = 0;
  397. }
  399. if (IPNetwork::add_membership(sock, addr) < 0)
  400. failure = 1;
  402. if (failure) {
  403. fprintf(stderr,
  404. "UDPIPNetwork(%s): add_membership: failed bind on mcast addr %s and INADDR_ANYn",
  405. name(), inet_ntoa(addr));
  406. }
  407. }
  409. //
  410. // server-side bind (or mcast subscription)
  411. //
  412. int
  413. UDPIPNetwork::bind(in_addr& addr, u_int16_t port)
  414. {
  415. NIDEBUG4("UDPIPNetwork(%s): attempt to bind to addr %s, port %d [net order]n",
  416. name(), inet_ntoa(addr), ntohs(port));
  417. if (rsock_ < 0) {
  418. fprintf(stderr,
  419. "UDPIPNetwork(%s): bind/listen called before net is openn",
  420. name());
  421. return (-1);
  422. }
  423. if (mode_ == O_WRONLY) {
  424. fprintf(stderr,
  425. "UDPIPNetwork(%s): attempted bind/listen but net is write-onlyn",
  426. name());
  427. return (-1);
  428. }
  429. #ifdef IP_ADD_MEMBERSHIP
  430.         if (IN_CLASSD(ntohl(addr.s_addr))) {
  431. // MULTICAST case, call UDPIP vers of add_membership
  432.                 add_membership(rsock_, addr, port);
  433.         } else
  434. #endif
  435.         {
  436. // UNICAST case
  437.                 sockaddr_in sin;
  438.                 if (bindsock(rsock_, addr, port, sin) < 0) {
  439.                         port = ntohs(port);
  440.                         fprintf(stderr,
  441.         "UDPIPNetwork(%s): bind: unable to bind %s [port:%hu]: %sn",
  442.                                 name(), inet_ntoa(addr),
  443.                                 port, strerror(errno));
  444. return (-1);
  445.                 }
  446.                 /*
  447.                  * MS Windows currently doesn't compy with the Internet Host
  448.                  * Requirements standard (RFC-1122) and won't let us include
  449.                  * the source address in the receive socket demux state.
  450.                  */
  451. #ifndef WIN32
  452.                 /*
  453.                  * (try to) connect the foreign host's address to this socket.
  454.                  */
  455.                 (void)connectsock(rsock_, addr, 0, sin);
  456. #endif
  457.         }
  458. localaddr_ = addr;
  459. lport_ = port;
  460. return (0);
  461. }
  463. //
  464. // client-side connect
  465. //
  466. int
  467. UDPIPNetwork::connect(in_addr& addr, u_int16_t port)
  468. {
  469. sockaddr_in sin;
  470. if (ssock_ < 0) {
  471. fprintf(stderr,
  472. "UDPIPNetwork(%s): connect called before net is openn",
  473. name());
  474. return (-1);
  475. }
  476. if (mode_ == O_RDONLY) {
  477. fprintf(stderr,
  478. "UDPIPNetwork(%s): attempted connect but net is read-onlyn",
  479. name());
  480. return (-1);
  481. }
  483. int rval = connectsock(ssock_, addr, port, sin);
  484. if (rval < 0)
  485. return (rval);
  486. destaddr_ = addr;
  487. port_ = port;
  488. last_reset_ = 0;
  489. return(rval);
  490. }
  492. int
  493. UDPIPNetwork::command(int argc, const char*const* argv)
  494. {
  495. Tcl& tcl = Tcl::instance();
  496. if (argc == 2) {
  497. // $udpip port
  498. if (strcmp(argv[1], "port") == 0) {
  499. tcl.resultf("%d", ntohs(port_));
  500. return (TCL_OK);
  501. }
  502. // $udpip lport
  503. if (strcmp(argv[1], "lport") == 0) {
  504. tcl.resultf("%d", ntohs(lport_));
  505. return (TCL_OK);
  506. }
  507. } else if (argc == 4) {
  508. // $udpip listen addr port
  509. // $udpip bind addr port
  510. if (strcmp(argv[1], "listen") == 0 ||
  511.     strcmp(argv[1], "bind") == 0) {
  512. in_addr addr;
  513. if (strcmp(argv[2], "any") == 0)
  514. addr.s_addr = INADDR_ANY;
  515. else
  516. addr.s_addr = LookupHostAddr(argv[2]);
  517. u_int16_t port = htons(atoi(argv[3]));
  518. if (bind(addr, port) < 0) {
  519. tcl.resultf("%s %hu",
  520. inet_ntoa(addr), port);
  521. } else {
  522. tcl.result("0");
  523. }
  524. return (TCL_OK);
  525. }
  526. // $udpip connect addr port
  527. if (strcmp(argv[1], "connect") == 0) {
  528. in_addr addr;
  529. addr.s_addr = LookupHostAddr(argv[2]);
  530. u_int16_t port = htons(atoi(argv[3]));
  531. if (connect(addr, port) < 0) {
  532. tcl.resultf("%s %hu",
  533. inet_ntoa(addr), port);
  534. } else {
  535. tcl.result("0");
  536. }
  537. return (TCL_OK);
  538. }
  539. }
  540. return (IPNetwork::command(argc, argv));
  541. }
  543. //
  544. // raw IP network recv()
  545. //
  546. int
  547. IPNetwork::recv(u_char* buf, int len, sockaddr& sa, double& ts)
  548. {
  549. if (mode_ == O_WRONLY) {
  550. fprintf(stderr,
  551.     "IPNetwork(%s) recv while in writeonly mode!n",
  552. name());
  553. abort();
  554. }
  555. int fromlen = sizeof(sa);
  556. int cc = ::recvfrom(rsock_, (char*)buf, len, 0, &sa, (socklen_t*)&fromlen);
  557. if (cc < 0) {
  558. if (errno != EWOULDBLOCK)
  559. perror("recvfrom");
  560. return (-1);
  561. }
  562. ts = Scheduler::instance().clock();
  563. return (cc);
  564. }
  566. //
  567. // we are given a "raw" IP datagram.
  568. // the raw interface appears to want the len and off fields
  569. // in *host* order, so make it this way here
  570. // note also, that it will compute the cksum "for" us... :(
  571. //
  572. int
  573. IPNetwork::send(u_char* buf, int len)
  574. {
  575. struct ip *ip = (struct ip*) buf;
  576. #ifdef __linux__ 
  577. // For raw sockets on linux the send does not work,
  578. // all packets show up only on the loopback device and are not routed
  579. // to the correct host. Using sendto on a closed socket solves this problem
  580.        ip->ip_len = (ip->ip_len);
  581.        ip->ip_off = (ip->ip_off);
  582.         sockaddr_in sin;
  583.        memset((char *)&sin, 0, sizeof(sin));
  584.        sin.sin_family = AF_INET;
  585.         sin.sin_addr = ip->ip_dst;
  586.        return (::sendto(ssock_, (char*)buf, len, 0,(sockaddr *) &sin,sizeof(sin)));
  587. #else
  588.         ip->ip_len = ntohs(ip->ip_len);
  589.         ip->ip_off = ntohs(ip->ip_off);
  590.         return (::send(ssock_, (char*)buf, len, 0));
  591. #endif
  592. }
  594. int IPNetwork::command(int argc, const char*const* argv)
  595. {
  596. Tcl& tcl = Tcl::instance();
  597. if (argc == 2) {
  598. if (strcmp(argv[1], "close") == 0) {
  599. close();
  600. return (TCL_OK);
  601. }
  602. // Old approach uses tcl.result() to get result buffer first
  603. // char* cp = tcl.result();
  604. // new approach uses tcl.result(const char*) directly.
  605. // xuanc, 10/07/2003
  606. if (strcmp(argv[1], "destaddr") == 0) {
  607. tcl.result(inet_ntoa(destaddr_));
  608. return (TCL_OK);
  609. }
  610. if (strcmp(argv[1], "localaddr") == 0) {
  611. tcl.result(inet_ntoa(localaddr_));
  612. return (TCL_OK);
  613. }
  614. if (strcmp(argv[1], "mttl") == 0) {
  615. tcl.resultf("%d", mttl_);
  616. return (TCL_OK);
  617. }
  618. /* for backward compatability */
  619. if (strcmp(argv[1], "ismulticast") == 0) {
  620. tcl.result(IN_CLASSD(ntohl(destaddr_.s_addr)) ?
  621. "1" : "0");
  622. return (TCL_OK);
  623. }
  624. if (strcmp(argv[1], "addr") == 0) {
  625. tcl.result(inet_ntoa(destaddr_));
  626. return (TCL_OK);
  627. }
  628. if (strcmp(argv[1], "ttl") == 0) {
  629. tcl.resultf("%d", mttl_);
  630. return (TCL_OK);
  631. }
  632. if (strcmp(argv[1], "interface") == 0) {
  633. tcl.result(inet_ntoa(localaddr_));
  634. return (TCL_OK);
  635. }
  636. } else if (argc == 3) {
  638. if (strcmp(argv[1], "open") == 0) {
  639. int mode = parsemode(argv[2]);
  640. if (open(mode) < 0)
  641. return (TCL_ERROR);
  642. return (TCL_OK);
  643. }
  644. if (strcmp(argv[1], "add-membership") == 0) {
  645. in_addr addr;
  646. addr.s_addr = LookupHostAddr(argv[2]);
  647. if (add_membership(rchannel(), addr) < 0)
  648. tcl.result("0");
  649. else
  650. tcl.result("1");
  651. return (TCL_OK);
  652. }
  653. if (strcmp(argv[1], "drop-membership") == 0) {
  654. in_addr addr;
  655. addr.s_addr = LookupHostAddr(argv[2]);
  656. if (drop_membership(rchannel(), addr) < 0)
  657. tcl.result("0");
  658. else
  659. tcl.result("1");
  660. return (TCL_OK);
  661. }
  662. if (strcmp(argv[1], "loopback") == 0) {
  663. int val = atoi(argv[2]);
  664. if (strcmp(argv[2], "true") == 0)
  665. val = 1;
  666. else if (strcmp(argv[2], "false") == 0)
  667. val = 0;
  668. if (setmloop(schannel(), val) < 0)
  669. tcl.result("0");
  670. else
  671. tcl.result("1");
  672. return (TCL_OK);
  673. }
  674. }
  675. return (Network::command(argc, argv));
  676. }
  677. int
  678. IPNetwork::setmttl(Socket s, int ttl)
  679. {
  680.         /* set the multicast TTL */  
  682. #ifdef WIN32
  683.         u_int t = ttl; 
  684. #else 
  685.         u_char t = ttl;
  686. #endif
  688.         t = (ttl > 255) ? 255 : (ttl < 0) ? 0 : ttl; 
  689.         if (::setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL,
  690.                        (char*)&t, sizeof(t)) < 0) {
  691. fprintf(stderr,
  692.     "IPNetwork(%s): couldn't set multicast ttl to %dn",
  693. name(), t);
  694.                 return (-1);
  695.         }
  696. return (0);
  697. }
  699. /*
  700.  * open a RAW IP socket (will require privilege).
  701.  * turn on HDRINCL, specifying that we will be writing the raw IP header
  702.  */
  704. int
  705. IPNetwork::open(int mode)
  706. {
  707. // obtain a raw socket we can use to send ip datagrams
  708. Socket fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
  709. if (fd < 0) {
  710. perror("socket(RAW)");
  711. if (::getuid() != 0 && ::geteuid() != 0) {
  712. fprintf(stderr,
  713.   "IPNetwork(%s): open: use of the Network/IP object requires super-user privsn",
  714. name());
  715. }
  717. return (-1);
  718. }
  720. // turn on HDRINCL option (we will be writing IP header)
  721. // in FreeBSD 2.2.5 (and possibly others), the IP id field
  722. // is set by the kernel routine rip_output()
  723. // only if it is non-zero, so we should be ok.
  724. int one = 1;
  725. if (::setsockopt(fd, IPPROTO_IP, IP_HDRINCL, &one, sizeof(one)) < 0) {
  726. fprintf(stderr,
  727. "IPNetwork(%s): open: unable to turn on IP_HDRINCL: %sn",
  728. name(), strerror(errno));
  729. return (-1);
  730. }
  731. #ifndef __linux__
  732. // sort of curious, but do a connect() even though we have
  733. // HDRINCL on.  Otherwise, we get ENOTCONN when doing a send()
  734. sockaddr_in sin;
  735. in_addr ia = { INADDR_ANY };
  736. if (connectsock(fd, ia, 0, sin) < 0) {
  737. fprintf(stderr,
  738. "IPNetwork(%s): open: unable to connect : %sn",
  739. name(), strerror(errno));
  740. }
  741. #endif
  742. rsock_ = ssock_ = fd;
  743. mode_ = mode;
  744. NIDEBUG5("IPNetwork(%s): opened with mode %d, rsock_:%d, ssock_:%dn",
  745. name(), mode_, rsock_, ssock_);
  746. return 0;
  747. }
  749. /*
  750.  * close both sending and receiving sockets
  751.  */
  753. int
  754. IPNetwork::close()
  755. {
  756. if (ssock_ >= 0) {
  757. (void)::close(ssock_);
  758. ssock_ = -1;
  759. }
  760. if (rsock_ >= 0) {
  761. (void)::close(rsock_);
  762. rsock_ = -1;
  763. }
  764. return (0);
  765. }
  767. /*
  768.  * add multicast group membership on the socket
  769.  */
  771. int
  772. IPNetwork::add_membership(Socket fd, in_addr& addr)
  773. {
  775. #if defined(IP_ADD_MEMBERSHIP)
  776. if (IN_CLASSD(ntohl(addr.s_addr))) {
  777. #ifdef notdef
  778. /*
  779.  * Try to bind the multicast address as the socket
  780.  * dest address.  On many systems this won't work
  781.  * so fall back to a destination of INADDR_ANY if
  782.  * the first bind fails.
  783.  */
  784. sockaddr_in sin;
  785. memset(&sin, 0, sizeof(sin));
  786. sin.sin_family = AF_INET;
  787. sin.sin_addr = addr;
  788. if (::bind(fd, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
  789. sin.sin_addr.s_addr = INADDR_ANY;
  790. if (::bind(fd, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
  791. fprintf(stderr,
  792. "IPNetwork(%s): add_membership: unable to bind to addr %s: %sn",
  793. name(), inet_ntoa(sin.sin_addr),
  794. strerror(errno));
  795. return (-1);
  796. }
  797. }
  798. #endif
  799. /* 
  800.  * XXX This is bogus multicast setup that really
  801.  * shouldn't have to be done (group membership should be
  802.  * implicit in the IP class D address, route should contain
  803.  * ttl & no loopback flag, etc.).  Steve Deering has promised
  804.  * to fix this for the 4.4bsd release.  We're all waiting
  805.  * with bated breath.
  806.  */
  807. struct ip_mreq mr;
  809. mr.imr_multiaddr = addr;
  810. mr.imr_interface.s_addr = INADDR_ANY;
  811. if (::setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, 
  812.        (char *)&mr, sizeof(mr)) < 0) {
  813. fprintf(stderr, "IPNetwork(%s): add_membership: unable to add membership for addr %s: %sn",
  814. name(), inet_ntoa(addr), strerror(errno));
  815. return (-1);
  816. }
  817. NIDEBUG3("IPNetwork(%s): add_membership for grp %s donen",
  818. name(), inet_ntoa(addr));
  819. return (0);
  820. }
  821. #else
  822. fprintf(stderr, "IPNetwork(%s): add_membership: host does not support IP multicastn",
  823. name());
  824. #endif
  825. NIDEBUG3("IPNetwork(%s): add_membership for grp %s failedn",
  826. name(), inet_ntoa(addr));
  827. return (-1);
  828. }
  830. /*
  831.  * drop membership from the specified group on the specified socket
  832.  */
  834. int
  835. IPNetwork::drop_membership(Socket fd, in_addr& addr)
  836. {
  838. #if defined(IP_DROP_MEMBERSHIP)
  839. if (IN_CLASSD(ntohl(addr.s_addr))) {
  840. struct ip_mreq mr;
  842. mr.imr_multiaddr = addr;
  843. mr.imr_interface.s_addr = INADDR_ANY;
  844. if (::setsockopt(fd, IPPROTO_IP, IP_DROP_MEMBERSHIP, 
  845.        (char *)&mr, sizeof(mr)) < 0) {
  846. fprintf(stderr, "IPNetwork(%s): drop_membership: unable to drop membership for addr %s: %sn",
  847. name(), inet_ntoa(addr), strerror(errno));
  848. return (-1);
  849. }
  850. NIDEBUG3("IPNetwork(%s): drop_membership for grp %s donen",
  851. name(), inet_ntoa(addr));
  852. return (0);
  853. }
  854. #else
  855. fprintf(stderr, "IPNetwork(%s): drop_membership: host does not support IP multicastn",
  856. name());
  857. #endif
  858. NIDEBUG3("IPNetwork(%s): drop_membership for grp %s failedn",
  859. name(), inet_ntoa(addr));
  860. return (-1);
  861. }
  863. int
  864. IPNetwork::bindsock(Socket s, in_addr& addr, u_int16_t port, sockaddr_in& sin)
  865. {
  866. memset((char *)&sin, 0, sizeof(sin));
  867. sin.sin_family = AF_INET;
  868. sin.sin_port = port;
  869. sin.sin_addr = addr;
  870. return(::bind(s, (struct sockaddr *)&sin, sizeof(sin)));
  871. }
  873. int
  874. IPNetwork::connectsock(Socket s, in_addr& addr, u_int16_t port, sockaddr_in& sin)
  875. {
  876. memset((char *)&sin, 0, sizeof(sin));
  877. sin.sin_family = AF_INET;
  878. sin.sin_port = port;
  879. sin.sin_addr = addr;
  880. return(::connect(s, (struct sockaddr *)&sin, sizeof(sin)));
  881. }
  882. int 
  883. IPNetwork::sbufsize(Socket s, int cnt)
  884. {   
  885.         return(::setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&cnt, sizeof(cnt)));
  886. }   
  888. int
  889. IPNetwork::rbufsize(Socket s, int cnt)
  890. {   
  891.         return(::setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&cnt, sizeof(cnt)));
  892. }   
  894. int
  895. IPNetwork::setmloop(Socket s, int loop)
  896. {
  898. #ifdef IP_MULTICAST_LOOP
  899. u_char c = loop;
  901. if (::setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, &c, sizeof(c)) < 0) {
  902. /*
  903.  * If we cannot turn off loopback (Like on the
  904.  * Microsoft TCP/IP stack), then declare this
  905.  * option broken so that our packets can be
  906.  * filtered on the recv path.
  907.  */
  908. if (c != loop) {
  909. noloopback_broken_ = 1;
  910. loop_ = c;
  911. }
  912. return (-1);
  913. }
  914. noloopback_broken_ = 0;
  915. #else
  916. fprintf(stderr, "IPNetwork(%s): msetloop: host does not support IP multicastn",
  917. name());
  918. #endif
  919. loop_ = c;
  920. return (0);
  921. }
  923. void
  924. IPNetwork::reset(int restart)
  925. {
  926. time_t t = time(0);
  927. int d = int(t - last_reset_);
  928. NIDEBUG2("IPNetwork(%s): resetn", name());
  929. if (d > 3) { // Steve: why?
  930. last_reset_ = t;
  931. if (ssock_ >= 0)
  932. (void)::close(ssock_);
  933. if (rsock_ >= 0)
  934. (void)::close(rsock_);
  935. if (open(mode_) < 0) {
  936. fprintf(stderr,
  937.   "IPNetwork(%s): couldn't resetn",
  938.   name());
  939. mode_ = -1;
  940. return;
  941. }
  942. if (restart)
  943. (void) reconfigure();
  944. }
  945. }
  947. /*
  948.  * after a reset, we may want to re-establish our state
  949.  * [set up addressing, etc].  Do this here
  950.  */
  952. void
  953. IPNetwork::reconfigure()
  954. {
  955. }
  957. void
  958. UDPIPNetwork::reconfigure()
  959. {
  960. }