ibm的一个sendmsg的例子，编译遇到一些问题

tsuibin

原地址
http://publib.boulder.ibm.com/in ... 2Fx1descriptors.htm

我在编译的时候有几个位置都报错，我想应该是结构体的头文件没加
但是不知道缺少哪几个？

代码如下：

1. /**************************************************************************/
   
2. /* Server example that uses sendmsg() to create worker jobs               */
   
3. /**************************************************************************/
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <sys/socket.h>
   
7. #include <netinet/in.h>
   
8. #include <spawn.h>
   
9. 
   
10. #define SERVER_PORT  12345
    
11. 
    
12. main (int argc, char *argv[])
    
13. {
    
14.    int    i, num, pid, rc, on = 1;
    
15.    int    listen_sd, accept_sd;
    
16.    int    server_sd, worker_sd, pair_sd[2];
    
17.    int    spawn_fdmap[1];
    
18.    char  *spawn_argv[1];
    
19.    char  *spawn_envp[1];
    
20.    struct inheritance   inherit;
    
21.    struct msghdr        msg;
    
22.    struct sockaddr_in6   addr;
    
23. 
    
24.    /*************************************************/
    
25.    /* If an argument was specified, use it to       */
    
26.    /* control the number of incoming connections    */
    
27.    /*************************************************/
    
28.    if (argc >= 2)
    
29.       num = atoi(argv[1]);
    
30.    else
    
31.       num = 1;
    
32. 
    
33.    /*************************************************/
    
34.    /* Create an AF_INET6 stream socket to receive   */
    
35.    /* incoming connections on                       */
    
36.    /*************************************************/
    
37.    listen_sd = socket(AF_INET6, SOCK_STREAM, 0);
    
38.    if (listen_sd < 0)
    
39.    {
    
40.       perror("socket() failed");
    
41.       exit(-1);
    
42.    }
    
43. 
    
44.    /*************************************************/
    
45.    /* Allow socket descriptor to be reuseable       */
    
46.    /*************************************************/
    
47.    rc = setsockopt(listen_sd,
    
48.                    SOL_SOCKET,  SO_REUSEADDR,
    
49.                    (char *)&on, sizeof(on));
    
50.    if (rc < 0)
    
51.    {
    
52.       perror("setsockopt() failed");
    
53.       close(listen_sd);
    
54.       exit(-1);
    
55.    }
    
56. 
    
57.    /*************************************************/
    
58.    /* Bind the socket                               */
    
59.    /*************************************************/
    
60.    memset(&addr, 0, sizeof(addr));
    
61.    addr.sin6_family      = AF_INET6;
    
62.    memcpy(&addr.sin6_addr, &in6addr_any, sizeof(in6addr_any));
    
63.    addr.sin6_port        = htons(SERVER_PORT);
    
64.    rc = bind(listen_sd,
    
65.              (struct sockaddr *)&addr, sizeof(addr));
    
66.    if (rc < 0)
    
67.    {
    
68.       perror("bind() failed");
    
69.       close(listen_sd);
    
70.       exit(-1);
    
71.    }
    
72. 
    
73.    /*************************************************/
    
74.    /* Set the listen back log                       */
    
75.    /*************************************************/
    
76.    rc = listen(listen_sd, 5);
    
77.    if (rc < 0)
    
78.    {
    
79.       perror("listen() failed");
    
80.       close(listen_sd);
    
81.       exit(-1);
    
82.    }
    
83. 
    
84.    /*************************************************/
    
85.    /* Create a pair of UNIX datagram sockets        */
    
86.    /*************************************************/
    
87.    rc = socketpair(AF_UNIX, SOCK_DGRAM, 0, pair_sd);
    
88.    if (rc != 0)
    
89.    {
    
90.       perror("socketpair() failed");
    
91.       close(listen_sd);
    
92.       exit(-1);
    
93.    }
    
94.    server_sd = pair_sd[0];
    
95.    worker_sd = pair_sd[1];
    
96. 
    
97.    /*************************************************/
    
98.    /* Initialize parms before entering for loop   */
    
99.    /*                                               */
    
100.    /* The worker socket descriptor is mapped to     */
     
101.    /* descriptor 0 in the child program.            */
     
102.    /*************************************************/
     
103.    memset(&inherit, 0, sizeof(inherit));
     
104.    spawn_argv[0]  = NULL;
     
105.    spawn_envp[0]  = NULL;
     
106.    spawn_fdmap[0] = worker_sd;
     
107. 
     
108.    /*************************************************/
     
109.    /* Create each of the worker jobs                */
     
110.    /*************************************************/
     
111.    printf("Creating worker jobs...\n");
     
112.    for (i=0; i < num; i++)
     
113.    {
     
114.       pid = spawn("/QSYS.LIB/QGPL.LIB/WRKR2.PGM",
     
115.                   1, spawn_fdmap, &inherit,
     
116.                   spawn_argv, spawn_envp);
     
117.       if (pid < 0)
     
118.       {
     
119.          perror("spawn() failed");
     
120.          close(listen_sd);
     
121.          close(server_sd);
     
122.          close(worker_sd);
     
123.          exit(-1);
     
124.       }
     
125.       printf("  Worker = %d\n", pid);
     
126.    }
     
127. 
     
128.    /*************************************************/
     
129.    /* Close down the worker side of the socketpair  */
     
130.    /*************************************************/
     
131.    close(worker_sd);
     
132. 
     
133.    /*************************************************/
     
134.    /* Inform the user that the server is ready      */
     
135.    /*************************************************/
     
136.    printf("The server is ready\n");
     
137. 
     
138.    /*************************************************/
     
139.    /* Go through the loop once for each connection  */
     
140.    /*************************************************/
     
141.    for (i=0; i < num; i++)
     
142.    {
     
143.       /**********************************************/
     
144.       /* Wait for an incoming connection            */
     
145.       /**********************************************/
     
146.       printf("Interation: %d\n", i+1);
     
147.       printf("  waiting on accept()\n");
     
148.       accept_sd = accept(listen_sd, NULL, NULL);
     
149.       if (accept_sd < 0)
     
150.       {
     
151.          perror("accept() failed");
     
152.          close(listen_sd);
     
153.          close(server_sd);
     
154.          exit(-1);
     
155.       }
     
156.       printf("  accept completed successfully\n");
     
157. 
     
158.       /**********************************************/
     
159.       /* Initialize message header structure        */
     
160.       /**********************************************/
     
161.       memset(&msg, 0, sizeof(msg));
     
162. 
     
163.       /**********************************************/
     
164.       /* We are not sending any data so we do not   */
     
165.       /* need to set either of the msg_iov fields.  */
     
166.       /* The memset of the message header structure */
     
167.       /* will set the msg_iov pointer to NULL and   */
     
168.       /* it will set the msg_iovcnt field to 0.     */
     
169.       /**********************************************/
     
170. 
     
171.       /**********************************************/
     
172.       /* The only fields in the message header      */
     
173.       /* structure that need to be filled in are    */
     
174.       /* the msg_accrights fields.                  */
     
175.       /**********************************************/
     
176.       msg.msg_accrights  = (char *)&accept_sd;
     
177.       msg.msg_accrightslen = sizeof(accept_sd);
     
178. 
     
179.       /**********************************************/
     
180.       /* Give the incoming connection to one of the */
     
181.       /* worker jobs.                               */
     
182.       /*                                            */
     
183.       /* NOTE: We do not know which worker job will */
     
184.       /*       get this inbound connection.         */
     
185.       /**********************************************/
     
186.       rc = sendmsg(server_sd, &msg, 0);
     
187.       if (rc < 0)
     
188.       {
     
189.          perror("sendmsg() failed");
     
190.          close(listen_sd);
     
191.          close(accept_sd);
     
192.          close(server_sd);
     
193.          exit(-1);
     
194.       }
     
195.       printf("  sendmsg completed successfully\n");
     
196. 
     
197.       /**********************************************/
     
198.       /* Close down the incoming connection since   */
     
199.       /* it has been given to a worker to handle    */
     
200.       /**********************************************/
     
201.       close(accept_sd);
     
202.    }
     
203. 
     
204.    /*************************************************/
     
205.    /* Close down the server and listen sockets      */
     
206.    /*************************************************/
     
207.    close(server_sd);
     
208.    close(listen_sd);
     
209. }

复制代码