home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Standards 1993 July / Disc.iso / misc / merit / idrp / faa / idrpsock.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-09  |  7.4 KB  |  326 lines
  1. /* idrp_sock.c
  2.  *
  3.  *  routines to handle
  4.  *  4 types of sockets used by IDRP 
  5.  * 
  6.  * idrp_ip_raw_sock_recv(pdu)
  7.  * idrp_clnp_sock_recv(pdu)
  8.  * idrp_idrp_sock_recv(pdu)
  9.  * idrp_udp_sock_recv(pdu)
  10.  * idrp_send_clnp_pdu(peer,p_buf,len,whereto)
  11.  * idrp_send_idrp_pdu(peer,p_buf,len,whereto)
  12.  *
  13.  */
  14.  
  15. #include "include.h"
  16. #include "idrp.h"
  17. #include "inet.h"
  18. #include <netiso/iso.h>
  19. #include <netiso/tp_user.h>
  20.  
  21.  
  22. /* 
  23.  * Socket initialization routine for IP PIDs 
  24.  */
  25.  
  26. idrpPeer *
  27. idrp_ip_raw_sock_recv(pdu_proto)
  28. idrp_proto_header    *pdu_proto;
  29. {
  30. idrp_fixed_ip_header    *p_ip;
  31. idrpPeer        *peer;
  32.  
  33.  
  34.     p_ip = (idrp_fixed_ip_header *) &pdu_proto->hdr.ip;
  35.  
  36.     /* is it really destined for me or is there some mistake 
  37.      * - I think we can take out this check
  38.      * - unless we are binding the IDRP to a OSPF
  39.      * - camp
  40.      */
  41.  
  42.     if (bcmp((caddr_t) &p_ip->hdr.ip_dst,(caddr_t) &idrp_this_node.gw.gw_addr->in.sin_addr,sizeof(struct in_addr)))
  43.          {
  44.                    tracef("IDRP IP PDU with bad destination %x",p_ip->hdr.ip_dst);
  45.         trace(TR_IDRP, 0, " from %x",p_ip->hdr.ip_src);
  46.         return ((idrpPeer *) 0);
  47.         }
  48.  
  49.     IDRP_LIST(peer)
  50.         {
  51.         if (!bcmp(&p_ip->hdr.ip_src,&peer->gw.gw_addr->in.sin_addr,sizeof(struct in_addr)))
  52.             {
  53.             /* match on IP address - we've got a peer - return peer */
  54.         
  55.             return (peer);
  56.             }    
  57.  
  58.         } IDRP_LIST_END;
  59.  
  60.     trace(TR_IDRP,0,"IDRP PID with unconfigured neighbor from %x",p_ip->hdr.ip_src);
  61.  
  62.     return ((idrpPeer *) 0);
  63. }
  64.  
  65. idrpPeer *
  66. idrp_udp_sock_recv(pdu_proto)
  67. idrp_proto_header *pdu_proto;
  68. {
  69. idrpPeer    *peer; 
  70. idrp_fixed_udp_header    *p_udp;
  71.  
  72.     p_udp = (idrp_fixed_udp_header *) &pdu_proto->hdr.udp;
  73.  
  74.     /* validate the ISO destination in UDP wrapper */
  75.  
  76.     if (isoaddr_netiso_cmp(&p_udp->hdr.dest, &rt_net))
  77.          {
  78.                    tracef("IDRP PDU with bad destination %A", sockbuild_iso((byte *) &p_udp->hdr.dest.isoa_genaddr,
  79.                     p_udp->hdr.dest.isoa_len));
  80.         trace(TR_IDRP, 0, " from %A", sockbuild_iso((byte *) &p_udp->hdr.src.isoa_genaddr,
  81.             p_udp->hdr.src.isoa_len));
  82.         }
  83.  
  84.     IDRP_LIST(peer)
  85.         {
  86.         if (!isoaddr_netiso_cmp(&p_udp->hdr.src, &peer->neighbor))
  87.         return (peer);
  88.                 break;
  89.         } IDRP_LIST_END;
  90.  
  91.         tracef("IDRP PDU with good destination %A", sockbuild_iso((byte *) p_udp->hdr.dest.isoa_genaddr,
  92.                     p_udp->hdr.dest.isoa_len));
  93.     trace(TR_IDRP, 0, " no-configured source: %A", sockbuild_iso((byte *) p_udp->hdr.src.isoa_genaddr,
  94.             p_udp->hdr.src.isoa_len));
  95.     
  96.     return ((idrpPeer *) 0);
  97. }
  98.  
  99.  
  100. idrpPeer *
  101. idrp_clnp_sock_recv(pdu_proto)
  102. idrp_proto_header    *pdu_proto;
  103. {
  104. idrpPeer    *peer;
  105. idrp_fixed_clnp_header    *p_clnp;
  106.  
  107.     /* Is this pdu destinated for me ? */
  108.  
  109.     p_clnp = (idrp_fixed_clnp_header *) &pdu_proto->hdr.clnp;
  110.  
  111.     /* validate the ISO destination in UDP wrapper */
  112.  
  113.     if (isoaddr_netiso_cmp(&p_clnp->dest, &rt_net))
  114.          {
  115.                    tracef("IDRP PDU with bad destination %A", sockbuild_iso((byte *) &p_clnp->dest.isoa_genaddr, \
  116.                     p_clnp->dest.isoa_len));
  117.         trace(TR_IDRP, 0," from %A", sockbuild_iso((byte *) &p_clnp->src.isoa_genaddr,p_clnp->src.isoa_len));
  118.         }
  119.      
  120.  
  121.     IDRP_LIST(peer) 
  122.         {
  123.         if (!isoaddr_netiso_cmp(&p_clnp->src, &peer->neighbor))
  124.             {
  125.             /* a match - so we have a peer
  126.              * - set length of iso addresses 
  127.              * in length
  128.              * return peer pointer
  129.              */
  130.             return (peer);
  131.             break;
  132.             }
  133.         } IDRP_LIST_END;
  134.  
  135.  
  136.        /* trace invalid pdu on  this socket */
  137.  
  138.     trace (TR_IDRP, 0, "IDRP PDU arrived from unconfigured neighbor %A", \
  139.         sockbuild_iso((byte *) p_clnp->src.isoa_genaddr, p_clnp->src.isoa_len));
  140.     
  141.  
  142. }
  143.  
  144. idrpPeer *
  145. idrp_idrp_sock_recv(pdu_proto)
  146. idrp_proto_header    *pdu_proto;
  147. {
  148. idrpPeer    *peer;
  149. idrp_fixed_idrp_header    *p_idrp;
  150.  
  151.     /* Is this pdu destinated for me ? */
  152.  
  153.     p_idrp = (idrp_fixed_idrp_header *) &pdu_proto->hdr.idrp;
  154.  
  155.     /* validate the ISO destination in socket call */
  156.  
  157.     if (isoaddr_netiso_cmp(&p_idrp->idrp_header.dest, &rt_net))
  158.          {
  159.                    tracef("IDRP PDU with bad destination %A", sockbuild_iso((byte *) p_idrp->idrp_header.dest.isoa_genaddr, \
  160.                     p_idrp->idrp_header.dest.isoa_len));
  161.         trace(TR_IDRP, 0, " from %A", sockbuild_iso((byte *) p_idrp->idrp_header.src.isoa_genaddr, \
  162.             p_idrp->idrp_header.src.isoa_len));
  163.         }
  164.      
  165.  
  166.     IDRP_LIST(peer) 
  167.         {
  168.         if (!isoaddr_netiso_cmp(&p_idrp->idrp_header.src, &peer->neighbor))
  169.             {
  170.             break;
  171.             }
  172.             } IDRP_LIST_END;
  173.  
  174.        /* trace invalid pdu on  this socket */
  175.  
  176.     trace (TR_IDRP, 0, "IDRP PDU arrived from unconfigured neighbor %A", \
  177.         sockbuild_iso((byte *) p_idrp->idrp_header.src.isoa_genaddr, p_idrp->idrp_header.src.isoa_len));
  178.  
  179. }
  180.  
  181. void
  182. idrp_send_clnp_pdu(peer,p_buf,len,where_to)
  183. idrpPeer    *peer;
  184. u_char    *p_buf;
  185. int    len;
  186. sockaddr_un    *where_to;
  187. {
  188. int i;
  189. struct sockaddr_iso    *p_iso_whereto;
  190.  
  191.     /* Turn this into sockadd_iso....
  192.     * It goes to the clnp_output via sendto
  193.     * com/sys/upic
  194.     */
  195.  
  196.     p_iso_whereto = (struct sockaddr_iso *) task_mem_malloc(peer->task,sizeof(struct sockaddr_iso));    
  197.     bzero(p_iso_whereto,sizeof(struct sockaddr_iso));
  198.     p_iso_whereto->siso_family = where_to->iso.siso_family;
  199.     /* setting the sockaddr_iso length to
  200.      * the length plus the psel, ssel, tsel 
  201.      *
  202.      */
  203.     
  204.     /* hard code for now - plus 5 bytes of header minus one bytes to make net */ 
  205.     p_iso_whereto->siso_len = where_to->iso.siso_len + 6 ; 
  206.     /* take off family and length */
  207.  
  208.     p_iso_whereto->siso_addr.isoa_len = where_to->iso.siso_len;
  209.  
  210.     bcopy(&where_to->iso.siso_addr,&p_iso_whereto->siso_addr.isoa_genaddr,where_to->iso.siso_len);
  211.     i = sendto(peer->task->task_socket,p_buf,len,0,p_iso_whereto,sizeof(struct sockaddr_iso));
  212.  
  213.     if (i < 0 || i != len)
  214.         {
  215.         if (i < 0)
  216.             {
  217.             trace (TR_IDRP,LOG_ERR, "IDRP cannot send CLNP buffer to peer %s errno %d",peer->name,errno);
  218.             return;
  219.             }
  220.         }
  221.     return;
  222. }
  223.     
  224.  
  225.  
  226. void idrp_send_idrp_pdu(peer,p_buf,len,whereto)
  227. idrpPeer    *peer;
  228. u_char    *p_buf;
  229. int    len;
  230. sockaddr_un    *whereto;
  231. {
  232. int i;
  233.  
  234.     i = sendto(peer->task->task_socket,p_buf,len,0,whereto,sizeof(whereto));
  235.     if (i < 0 || i != len)
  236.         {
  237.         if (i < 0)
  238.             {
  239.             trace (TR_IDRP,LOG_ERR, "IDRP cannot send IDRP PDU via IDRPsocket to peer %s, peer->name");
  240.             }
  241.         }
  242. }
  243.  
  244.  
  245. int
  246. proto_offset(p_pdu,pdu_proto,proto_sock)
  247. idrpPdu    **p_pdu;
  248. idrp_proto_header    *pdu_proto;
  249. int            proto_sock;
  250. {
  251. idrpPeer    *peer;
  252. int        header_len;
  253.  
  254.     switch (proto_sock)
  255.         {
  256.         case IDRP_PDU_PROTO_IP_RAW:
  257.             /* no header needed for protocol for IP send */
  258.             *p_pdu = (idrpPdu *) pdu_proto;
  259.                         header_len = 0;
  260.                         break;
  261.  
  262.         case IDRP_PDU_PROTO_UDP:
  263.             /* UDP always has ISO addresses */
  264.  
  265.             *p_pdu = (idrpPdu *) &pdu_proto->hdr.udp.pdu;
  266.             header_len = IDRP_UDP_HEADER_LEN;
  267.             break;
  268.  
  269.         case IDRP_PDU_PROTO_CLNP:
  270.             /* CLNP has just pdu - I hope */
  271.             
  272.             *p_pdu = (idrpPdu *) pdu_proto;
  273.             header_len = 0;
  274.             break;
  275.     
  276.         case IDRP_PDU_PROTO_IDRP:
  277.             /* IDRP has just pdu - I hope */
  278.         
  279.             *p_pdu = (idrpPdu *) pdu_proto;
  280.             header_len = 0;
  281.             break;
  282.         }
  283. return (header_len);
  284. }
  285.  
  286. int send_next_hop(p_atts,peer)
  287. idrp_attribute_record    *p_atts;
  288. idrpPeer        *peer;
  289. {
  290.     if (!p_atts->next_hop)
  291.         {
  292.         return(FALSE);
  293.         }
  294.  
  295.     /* if the don't send the next hop set from this
  296.      * pdu, then don't send the  pdu byte
  297.      */
  298.  
  299.     if (p_atts->local_mask & IDRP_DONT_SEND_NEXT_HOP)
  300.         {
  301.         return (FALSE);
  302.         }
  303.  
  304.     switch (idrp_this_node.proto_sock)
  305.         {
  306.         case IDRP_PDU_PROTO_UDP:
  307.         case IDRP_PDU_PROTO_IP_RAW:
  308.             if (sockaddrcmp(p_atts->next_hop,peer->gw.gw_addr))
  309.                 {
  310.                 p_atts->attrib[IDRP_ATTR_NEXT_HOP].present = FALSE;    
  311.                 return(TRUE);
  312.                 }
  313.             break;
  314.  
  315.         case IDRP_PDU_PROTO_CLNP:
  316.         case IDRP_PDU_PROTO_IDRP:
  317.             if (sockaddrcmp(p_atts->next_hop,peer->iso_gw.gw_addr));
  318.                 {
  319.                 p_atts->attrib[IDRP_ATTR_NEXT_HOP].present = FALSE;    
  320.                 return(TRUE);    
  321.                 }
  322.             break;
  323.         }
  324.     return(FALSE);
  325. }
  326.