home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / sun / volume3 / strace / part02 / net.c next >
C/C++ Source or Header  |  1992-03-02  |  9KB  |  458 lines
  1. /*
  2.  * @(#)net.c    2.5 92/01/21    - communications system calls
  3.  */
  4.  
  5. #include <stdio.h>
  6. #include <sys/types.h>
  7. #include <sys/ptrace.h>
  8. #include <sys/file.h>
  9. #include <sys/stat.h>
  10. #include <sys/time.h>
  11. #include <sys/socket.h>
  12. #include <sys/un.h>
  13. #include <netinet/in.h>
  14. #include <arpa/inet.h>
  15.  
  16. #include "defs.h"
  17.  
  18. static Xlat domains[] = {
  19.     PF_UNIX,    "PF_UNIX",
  20.     PF_INET,    "PF_INET",
  21. #ifdef    PF_IMPLINK
  22.     PF_IMPLINK,    "PF_IMPLINK",
  23. #endif
  24.     0,        NULL,
  25. };
  26. static Xlat socktypes[] = {
  27.     SOCK_STREAM,    "STREAM",
  28.     SOCK_DGRAM,    "DGRAM",
  29.     SOCK_RAW,    "RAW",
  30. #ifdef    SOCK_SEQPACKET
  31.     SOCK_SEQPACKET,    "SEQ_PKT",
  32. #endif
  33. #ifdef    SOCK_RDM
  34.     SOCK_RDM,    "RDM",
  35. #endif
  36.     0,        NULL,
  37. };
  38. static Xlat protocols[] = {
  39.     IPPROTO_IP,    "IPPROTO_IP",
  40.     IPPROTO_ICMP,    "IPPROTO_ICMP",
  41.     IPPROTO_TCP,    "IPPROTO_TCP",
  42.     IPPROTO_UDP,    "IPPROTO_UDP",
  43. #ifdef    IPPROTO_IGMP
  44.     IPPROTO_IGMP,    "IPPROTO_IGMP",
  45. #endif
  46. #ifdef    IPPROTO_GGP
  47.     IPPROTO_GGP,    "IPPROTO_GGP",
  48. #endif
  49. #ifdef    IPPROTO_EGP
  50.     IPPROTO_EGP,    "IPPROTO_EGP",
  51. #endif
  52. #ifdef    IPPROTO_PUP
  53.     IPPROTO_PUP,    "IPPROTO_PUP",
  54. #endif
  55. #ifdef    IPPROTO_IDP
  56.     IPPROTO_IDP,    "IPPROTO_IDP",
  57. #endif
  58. #ifdef    IPPROTO_HELLO
  59.     IPPROTO_HELLO,    "IPPROTO_HELLO",
  60. #endif
  61. #ifdef    IPPROTO_ND
  62.     IPPROTO_ND,    "IPPROTO_ND",
  63. #endif
  64. #ifdef    IPPROTO_RAW
  65.     IPPROTO_RAW,    "IPPROTO_RAW",
  66. #endif
  67.     0,        NULL,
  68. };
  69. static Xlat msg_flags[] = {
  70.     MSG_OOB,    "OOB",
  71.     MSG_DONTROUTE,    "DONTROUTE",
  72.     0,         NULL,
  73. };
  74.  
  75. static Xlat sockoptions[] = {
  76.     SO_DEBUG,    "DEBUG",
  77.     SO_ACCEPTCONN,    "ACCEPTCONN",
  78.     SO_REUSEADDR,    "REUSEADDR",
  79.     SO_KEEPALIVE,    "KEEPALIVE",
  80.     SO_DONTROUTE,    "DONTROUTE",
  81.     SO_BROADCAST,    "BROADCAST",
  82.     SO_USELOOPBACK,    "USELOOPBACK",
  83.     SO_LINGER,    "LINGER",
  84.     SO_OOBINLINE,    "OOBINLINE",
  85.     SO_SNDBUF,    "SNDBUF",
  86.     SO_RCVBUF,    "RCVBUF",
  87.     SO_SNDLOWAT,    "SNDLOWAT",
  88.     SO_RCVLOWAT,    "RCVLOWAT",
  89.     SO_SNDTIMEO,    "SNDTIMEO",
  90.     SO_RCVTIMEO,    "RCVTIMEO",
  91.     SO_ERROR,    "ERROR",
  92.     SO_TYPE,    "TYPE",
  93.     0,        NULL,
  94. };
  95.  
  96. void
  97. printsock(pid, addr)
  98. {
  99.     struct sockaddr sa;
  100.     struct sockaddr_in *sin = (struct sockaddr_in *)&sa;
  101.     struct sockaddr_un sau;
  102.  
  103.     if (addr == 0 || umove(pid, addr, sizeof sa, (char *)&sa) < 0) {
  104.         tprintf("(struct sockaddr *)%#x", addr);
  105.         return;
  106.     }
  107.     switch (sa.sa_family) {
  108.     case AF_UNIX:
  109.         if (umove(pid, addr, sizeof sau, (char *)&sau) < 0)
  110.             sau.sun_path[0] = '\0';
  111.         tprintf("AF_UNIX(%s)", sau.sun_path);
  112.         break;
  113.     case AF_INET:
  114.         tprintf("AF_INET(%u, %s)",
  115.             ntohs(sin->sin_port), inet_ntoa(sin->sin_addr));
  116.         break;
  117.     default:
  118.         tprintf("PF_UNSPEC");
  119.         break;
  120.     }
  121. }
  122.  
  123. static void
  124. printmsghdr(pid, addr)
  125. {
  126.     struct msghdr msg;
  127.  
  128.     if (addr == 0 || umove(pid, addr, sizeof msg, (char *)&msg) < 0) {
  129.         tprintf("(struct msghdr *)%#x", addr);
  130.         return;
  131.     }
  132.     tprintf("[name %s len %u iovec %#x iovlen %u acc %#x acclen %u]",
  133.         msg.msg_name, msg.msg_namelen,
  134.         msg.msg_iov, msg.msg_iovlen,
  135.         msg.msg_accrights, msg.msg_accrightslen);
  136. }
  137.  
  138. int
  139. sys_socket(tcp)
  140. struct tcb *tcp;
  141. {
  142.     if (entering(tcp)) {
  143.         printxval(domains, tcp->u_args[0], "PF_???");
  144.         tprintf(", ");
  145.         printxval(socktypes, tcp->u_args[1], "SOCK_???");
  146.         tprintf(", ");
  147.         if (tcp->u_args[0] == PF_INET) {
  148.             printxval(protocols, tcp->u_args[2], "IPPROTO_???");
  149.         } else {
  150.             tprintf("%u", tcp->u_args[2]);
  151.         }
  152.     }
  153.     return 0;
  154. }
  155.  
  156. int
  157. sys_bind(tcp)
  158. struct tcb *tcp;
  159. {
  160.     if (entering(tcp)) {
  161.         tprintf("%u, ", tcp->u_args[0]);
  162.         printsock(tcp->pid, tcp->u_args[1]);
  163.         tprintf(", %u", tcp->u_args[2]);
  164.     }
  165.     return 0;
  166. }
  167.  
  168. int
  169. sys_connect(tcp)
  170. struct tcb *tcp;
  171. {
  172.     return sys_bind(tcp);
  173. }
  174.  
  175. int
  176. sys_listen(tcp)
  177. struct tcb *tcp;
  178. {
  179.     if (entering(tcp)) {
  180.         tprintf("%u, %u", tcp->u_args[0], tcp->u_args[1]);
  181.     }
  182.     return 0;
  183. }
  184.  
  185. int
  186. sys_accept(tcp)
  187. struct tcb *tcp;
  188. {
  189.     int len;
  190.  
  191.     if (entering(tcp)) {
  192.         tprintf("%u, ", tcp->u_args[0]);
  193.     } else {
  194.         if (tcp->u_args[2] == 0 || umove(tcp->pid, tcp->u_args[2],
  195.                         sizeof len, (char *)&len) < 0) {
  196.             tprintf("(struct sockaddr *)%#x, (int *)0",
  197.                         tcp->u_args[1]);
  198.             return 0;
  199.         }
  200.         if (syserror(tcp)) {
  201.             tprintf("%#x, %u", tcp->u_args[1], len);
  202.         } else {
  203.             printsock(tcp->pid, tcp->u_args[1]);
  204.             tprintf(", %u", len);
  205.         }
  206.     }
  207.     return 0;
  208. }
  209.  
  210. int
  211. sys_send(tcp)
  212. struct tcb *tcp;
  213. {
  214.     if (entering(tcp)) {
  215.         tprintf("%u, ", tcp->u_args[0]);
  216.         (void)printstr(tcp->pid, tcp->u_args[1], tcp->u_args[2]);
  217.         /* flags */
  218.         tprintf(", ");
  219.         if (printflags(msg_flags, tcp->u_args[3]) == 0)
  220.             tprintf("0");
  221.     }
  222.     return 0;
  223. }
  224.  
  225. int
  226. sys_sendto(tcp)
  227. struct tcb *tcp;
  228. {
  229.     if (entering(tcp)) {
  230.         tprintf("%u, ", tcp->u_args[0]);
  231.         (void)printstr(tcp->pid, tcp->u_args[1], tcp->u_args[2]);
  232.         /* flags */
  233.         tprintf(", %u, ", tcp->u_args[2]);
  234.         if (printflags(msg_flags, tcp->u_args[3]) == 0)
  235.             tprintf("0");
  236.  
  237.         /* to address */
  238.         tprintf(", ");
  239.         printsock(tcp->pid, tcp->u_args[4]);
  240.         /* to length */
  241.         tprintf(", %u", tcp->u_args[5]);
  242.     }
  243.     return 0;
  244. }
  245.  
  246. int
  247. sys_sendmsg(tcp)
  248. struct tcb *tcp;
  249. {
  250.     if (entering(tcp)) {
  251.         tprintf("%u, ", tcp->u_args[0]);
  252.         printmsghdr(tcp->pid, tcp->u_args[1]);
  253.         /* flags */
  254.         tprintf(", ");
  255.         if (printflags(msg_flags, tcp->u_args[2]) == 0)
  256.             tprintf("0");
  257.     }
  258.     return 0;
  259. }
  260.  
  261. int
  262. sys_recv(tcp)
  263. struct tcb *tcp;
  264. {
  265.     if (entering(tcp)) {
  266.         tprintf("%u, ", tcp->u_args[0]);
  267.     } else {
  268.         if (syserror(tcp))
  269.             tprintf("%#x", tcp->u_args[1]);
  270.         else
  271.             (void)printstr(tcp->pid, tcp->u_args[1], tcp->u_rval);
  272.  
  273.         tprintf(", %u, ", tcp->u_args[2]);
  274.         if (printflags(msg_flags, tcp->u_args[3]) == 0)
  275.             tprintf("0");
  276.     }
  277.     return 0;
  278. }
  279.  
  280. int
  281. sys_recvfrom(tcp)
  282. struct tcb *tcp;
  283. {
  284.     int fromlen;
  285.  
  286.     if (entering(tcp)) {
  287.         tprintf("%u, ", tcp->u_args[0]);
  288.     } else {
  289.         if (syserror(tcp)) {
  290.             tprintf("%#x, %u, %u, %#x, %#x",
  291.                 tcp->u_args[1], tcp->u_args[2], tcp->u_args[3],
  292.                 tcp->u_args[4], tcp->u_args[5]);
  293.         }
  294.         /* buf */
  295.         (void)printstr(tcp->pid, tcp->u_args[1], tcp->u_rval);
  296.         /* len */
  297.         tprintf(", %u, ", tcp->u_args[2]);
  298.         /* flags */
  299.         if (printflags(msg_flags, tcp->u_args[3]) == 0)
  300.             tprintf("0");
  301.  
  302.         /* from address, len */
  303.         if (tcp->u_args[5] == 0 || umove(tcp->pid, tcp->u_args[5],
  304.                     sizeof fromlen, (char *)&fromlen) < 0) {
  305.             tprintf(", (struct sockaddr *)%#x, (int *)0",
  306.                     tcp->u_args[4]);
  307.             return 0;
  308.         }
  309.         tprintf(", ");
  310.         printsock(tcp->pid, tcp->u_args[4]);
  311.         tprintf(", %u", fromlen);
  312.     }
  313.     return 0;
  314. }
  315.  
  316. int
  317. sys_recvmsg(tcp)
  318. struct tcb *tcp;
  319. {
  320.     if (entering(tcp)) {
  321.         tprintf("%u, ", tcp->u_args[0]);
  322.     } else {
  323.         if (syserror(tcp))
  324.             tprintf("(struct msghdr *)%#x", tcp->u_args[1]);
  325.         else
  326.             printmsghdr(tcp->pid, tcp->u_args[1]);
  327.         /* flags */
  328.         tprintf(", ");
  329.         if (printflags(msg_flags, tcp->u_args[2]) == 0)
  330.             tprintf("0");
  331.     }
  332.     return 0;
  333. }
  334.  
  335. int
  336. sys_shutdown(tcp)
  337. struct tcb *tcp;
  338. {
  339.     if (entering(tcp)) {
  340.         tprintf("%u, ", tcp->u_args[0]);
  341.         switch (tcp->u_args[1]) {
  342.         case 0:
  343.             tprintf("%s", "RECEIVE");
  344.             break;
  345.         case 1:
  346.             tprintf("%s", "SEND");
  347.             break;
  348.         case 2:
  349.             tprintf("%s", "SEND/RECEIVE");
  350.             break;
  351.         default:
  352.             tprintf("???(%u)", tcp->u_args[1]);
  353.             break;
  354.         }
  355.     }
  356.     return 0;
  357. }
  358.  
  359. int
  360. sys_getsockname(tcp)
  361. struct tcb *tcp;
  362. {
  363.     return sys_accept(tcp);
  364. }
  365.  
  366. int
  367. sys_getpeername(tcp)
  368. struct tcb *tcp;
  369. {
  370.     return sys_accept(tcp);
  371. }
  372.  
  373. int
  374. sys_pipe(tcp)
  375. struct tcb *tcp;
  376. {
  377.     if (exiting(tcp)) {
  378.         tprintf("[%u,%u]", tcp->u_rval, getrval2(tcp->pid));
  379.     }
  380.     return 0;
  381. }
  382.  
  383. int
  384. sys_socketpair(tcp)
  385. struct tcb *tcp;
  386. {
  387.     if (entering(tcp)) {
  388.         printxval(domains, tcp->u_args[0], "PF_???");
  389.         tprintf(", ");
  390.         printxval(socktypes, tcp->u_args[1], "SOCK_???");
  391.         tprintf(", ");
  392.         if (tcp->u_args[0] == PF_INET) {
  393.             printxval(protocols, tcp->u_args[2], "IPPROTO_???");
  394.         } else {
  395.             tprintf("%u", tcp->u_args[2]);
  396.         }
  397.     } else {
  398.         if (!syserror(tcp))
  399.             tprintf(", [%u,%u]", tcp->u_rval, getrval2(tcp->pid));
  400.     }
  401.     return 0;
  402. }
  403.  
  404. int
  405. sys_getsockopt(tcp)
  406. struct tcb *tcp;
  407. {
  408.     int    optlen;
  409.  
  410.     if (entering(tcp)) {
  411.         tprintf("%u, ", tcp->u_args[0]);
  412.         if (tcp->u_args[1] == SOL_SOCKET) {
  413.             tprintf("SOL_SOCKET, ");
  414.             printxval(sockoptions, tcp->u_args[2], "SO_???");
  415.             tprintf(", ");
  416.         } else {
  417.             /* XXX - should know socket family here */
  418.             printxval(protocols, tcp->u_args[1], "IPPROTO_???");
  419.             tprintf(", %u, ", tcp->u_args[2]);
  420.         }
  421.     } else {
  422.         if (syserror(tcp)) {
  423.             tprintf("%#x, %#x", tcp->u_args[3], tcp->u_args[4]);
  424.             return 0;
  425.         }
  426.         if (tcp->u_args[4] == 0 || umove(tcp->pid, tcp->u_args[4],
  427.                 sizeof optlen, (char *)&optlen) < 0) {
  428.             tprintf("%#x, (int *)%#x",
  429.                     tcp->u_args[3], tcp->u_args[4]);
  430.             return 0;
  431.         }
  432.         (void)printstr(tcp->pid, tcp->u_args[3], optlen);
  433.         tprintf(", %u", tcp->u_args[4]);
  434.     }
  435.     return 0;
  436. }
  437.  
  438. int
  439. sys_setsockopt(tcp)
  440. struct tcb *tcp;
  441. {
  442.     if (entering(tcp)) {
  443.         tprintf("%u, ", tcp->u_args[0]);
  444.         if (tcp->u_args[1] == SOL_SOCKET) {
  445.             tprintf("SOL_SOCKET, ");
  446.             printxval(sockoptions, tcp->u_args[2], "SO_???");
  447.             tprintf(", ");
  448.         } else {
  449.             /* XXX - should know socket family here */
  450.             printxval(protocols, tcp->u_args[1], "IPPROTO_???");
  451.             tprintf(", %u, ", tcp->u_args[2]);
  452.         }
  453.         (void)printstr(tcp->pid, tcp->u_args[3], tcp->u_args[4]);
  454.         tprintf(", %u", tcp->u_args[4]);
  455.     }
  456.     return 0;
  457. }
  458.