编译时期莫名其妙的错误

yufeng8552

[root@BillingServer test]# gcc -o tcpsock tcpsock.c
In file included from tcpsock.c:4:
tcpsock.h:17:28: sys/netinet/in.h: 没有那个文件或目录
tcpsock.h:18:29: sys/netinet/tcp.h: 没有那个文件或目录
tcpsock.c: In function `CreateConnection':
tcpsock.c:130: incompatible types in assignment
tcpsock.c: In function `AcceptConnection':
tcpsock.c:142: warning: passing arg 2 of `accept' from incompatible pointer type
tcpsock.c:162: incompatible types in assignment
tcpsock.c: In function `QuerySocketsMsg':
tcpsock.c:209: invalid operands to binary /
tcpsock.c:215: invalid operands to binary /
tcpsock.c:224: invalid operands to binary /
tcpsock.c:256:2: warning: no newline at end of file

这个文件原来是sco unix里头的，是不是和linux里的头文件有区别，要屏蔽一些头文件？

tcpsock.c文件如下：

1. 
   
2. /* File Name: tcpsock.c */
   
3. /* 本文件给出九个函数的源代码,其中部分地方给出中文注释 */
   
4. 
   
5. #include "tcpsock.h"
   
6. 
   
7. int InitSocketsStruct(char * servicename)
   
8. /* Initialize Sockets structure. If succeed then return 1, else return error code (<0) */
   
9. /* 此函数用于只需要主动套接字的客户程序,它用来获取服务信息.服务的定义在/etc/services文件中 */
   
10. {
    
11.         struct servent *servrec;
    
12.         struct sockaddr_in serv_addr;
    
13.         if ((servrec = getservbyname(servicename, "tcp")) == NULL)
    
14.         {
    
15.                 return(-1);
    
16.         }
    
17.        
    
18.         bzero((char *)&Mysock, sizeof(Sockets));
    
19.         Mysock.Port = servrec->s_port; /* Service Port in Network Byte Order */
    
20.         return(1);
    
21. }
    
22. 
    
23. 
    
24. int InitPassiveSock(char * servicename)
    
25. /* Initialize Passive Socket. If succeed then return 1, else return error code (<0) */
    
26. /* 此函数用于需要被动套接字的服务器程序,它除了获取服务信息外,还建立一个被动套接字.*/
    
27. 
    
28. {
    
29.         int mainsock, flag=1;
    
30.         struct servent *servrec;
    
31.         struct sockaddr_in serv_addr;
    
32.         if ((servrec = getservbyname(servicename, "tcp")) == NULL)
    
33.         {
    
34.                 return(-1);
    
35.         }
    
36.        
    
37.         bzero((char *)&Mysock, sizeof(Sockets));
    
38.         Mysock.Port = servrec->s_port; /* Service Port in Network Byte Order */
    
39. 
    
40.         if((mainsock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    
41.         {
    
42.                 return(-2);
    
43.         }
    
44. 
    
45.         bzero((char *)&serv_addr, sizeof(serv_addr));
    
46.         serv_addr.sin_family = AF_INET;
    
47.         serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* 任意网络接口 */
    
48.         serv_addr.sin_port = servrec->s_port;
    
49.         if (bind(mainsock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0)
    
50.         {
    
51.                 close(mainsock);
    
52.                 return(-3);
    
53.         }
    
54. 
    
55.         if (listen(mainsock, 5) == -1) /* 将主动套接字变为被动套接字,准备好接收连接 */
    
56.         {
    
57.                 close(mainsock);
    
58.                 return(-4);
    
59.         }
    
60. 
    
61.         /* Set this socket as a Non-blocking socket. */
    
62.         if (ioctl(mainsock, FIONBIO, &flag) == -1)
    
63.         {
    
64.                 close(mainsock);
    
65.                 return(-5);
    
66.         }
    
67. 
    
68.         Mysock.DaemonSock = mainsock;
    
69.         FD_SET(mainsock, &Mysock.readfds); /* 申明对主套接字“可读”感兴趣 */
    
70.         FD_SET(mainsock, &Mysock.exceptfds); /* 申明对主套接字上例外事件感兴趣 */
    
71.         return(1);
    
72. }
    
73. 
    
74. 
    
75. void CloseMainSock()
    
76. /* 关闭主套接字,并清除对它上面事件的申明.在程序结束前关闭主套接字是一个好习惯 */
    
77. {
    
78.         close(Mysock.DaemonSock);
    
79.         FD_CLR(Mysock.DaemonSock, &Mysock.readfds);
    
80.         FD_CLR(Mysock.DaemonSock, &Mysock.exceptfds);
    
81. }
    
82. 
    
83. int CreateConnection(struct in_addr *sin_addr)
    
84. /* Create a Connection to remote host which IP address is in sin_addr.
    
85.    Param: sin_addr indicates the IP address in Network Byte Order.
    
86.    if succeed return the socket number which indicates this connection,
    
87.    else return error code (<0) */
    
88. {
    
89.         struct sockaddr_in server; /* server address */
    
90.         int tmpsock, flag=1, i;
    
91. 
    
92.         if ((tmpsock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    
93.                 return(-1);
    
94. 
    
95.         server.sin_family = AF_INET;
    
96.         server.sin_port = Mysock.Port;
    
97.         server.sin_addr.s_addr = sin_addr->s_addr;
    
98. 
    
99.         /* Set this socket as a Non-blocking socket. */
    
100.         if (ioctl(tmpsock, FIONBIO, &flag) == -1)
     
101.         {
     
102.                 close(tmpsock);
     
103.                 return(-2);
     
104.         }
     
105. 
     
106.         /* Connect to the server. */
     
107.         if (connect(tmpsock, (struct sockaddr *)&server, sizeof(server)) < 0)
     
108.         {
     
109.                 if ((errno != EWOULDBLOCK) && (errno != EINPROGRESS))
     
110.                 {
     
111.                         /* 如果错误代码是EWOULDBLOCK和EINPROGRESS,则不用关闭套接字,
     
112.                            因为系统将在之后继续为套接字建立连接,连接是否建立成功可用select()函数来检测套接字是否“可写”来确定.*/
     
113.                         close(tmpsock);
     
114.                         return(-3); /* Connect error. */
     
115.                 }
     
116.         }
     
117. 
     
118.         FD_SET(tmpsock, &Mysock.readfds);
     
119.         FD_SET(tmpsock, &Mysock.writefds);
     
120.         FD_SET(tmpsock, &Mysock.exceptfds);
     
121.        
     
122.         i = 0;
     
123.         while (Mysock.Sockets != 0) i++; /* look for a blank sockets position */
     
124. 
     
125.         if (i >= 64)
     
126.         {
     
127.                 close(tmpsock);
     
128.                 return(-4); /* too many connections */
     
129.         }
     
130. 
     
131.         Mysock.Sockets = tmpsock;
     
132.         Mysock.SockNum++;
     
133.         return(i);
     
134. }
     
135. 
     
136. int AcceptConnection(struct in_addr *IPaddr)
     
137. /* Accept a connection. If succeed, return the data sockets number, else return -1. */
     
138. {
     
139.         int newsock, len, flag=1, i;
     
140.         struct sockaddr_in addr;
     
141.         len = sizeof(addr);
     
142.         bzero((char *)&addr, len);
     
143.         if ((newsock = accept(Mysock.DaemonSock, &addr, &len)) == -1)
     
144.                 return(-1); /* Accept error. */
     
145. 
     
146.         /* Set this socket as a Non-blocking socket. */
     
147.         ioctl(newsock, FIONBIO, &flag);
     
148.         FD_SET(newsock, &Mysock.readfds);
     
149.         FD_SET(newsock, &Mysock.writefds);
     
150.         FD_SET(newsock, &Mysock.exceptfds);
     
151.        
     
152.         /* Return IP address in the Parameter. */
     
153.         IPaddr->s_addr = addr.sin_addr.s_addr;
     
154. 
     
155.         i = 0;
     
156.         while (Mysock.Sockets != 0) i++; /* look for a blank sockets position */
     
157.         if (i >= 64)
     
158.         {
     
159.                 close(newsock);
     
160.                 return(-4); /* too many connections */
     
161.         }
     
162.        
     
163.         Mysock.Sockets = newsock;
     
164.         Mysock.SockNum++;
     
165.         return(i);
     
166. }
     
167. 
     
168. int CloseConnection(int Sockno)
     
169. /* Close a connection indicated by Sockno. */
     
170. {
     
171.         int retcode;
     
172. 
     
173.         if ((Sockno >= 64) || (Sockno < 0) || (Mysock.Sockets[Sockno] == 0))
     
174.                 return(0);
     
175. 
     
176.         retcode = close(Mysock.Sockets[Sockno]);
     
177.         FD_CLR(Mysock.Sockets[Sockno], &Mysock.readfds);
     
178.         FD_CLR(Mysock.Sockets[Sockno], &Mysock.writefds);
     
179.         FD_CLR(Mysock.Sockets[Sockno], &Mysock.exceptfds);
     
180. 
     
181.         Mysock.Sockets[Sockno] = 0;
     
182.         Mysock.SockNum--;
     
183.         return(retcode);
     
184. }
     
185. 
     
186. 
     
187. int QuerySocketsMsg()
     
188. /* Query Sockets Message. If succeed return message number, else return -1.
     
189.    The message information stored in struct SockMsg. */
     
190. {
     
191.         fd_set rfds, wfds, efds;
     
192.         int retcode, i;
     
193.         struct timeval TimeOut;
     
194.        
     
195.         rfds = Mysock.readfds;
     
196.         wfds = Mysock.writefds;
     
197.         efds = Mysock.exceptfds;
     
198.         TimeOut.tv_sec = 0; /* 立即返回,不阻塞.*/
     
199.         TimeOut.tv_usec = 0;
     
200.        
     
201.         bzero((char *)&SockMsg, sizeof(SockMsg));
     
202. 
     
203.         if ((retcode = select(64, &rfds, &wfds, &efds, &TimeOut)) == 0)
     
204.                 return(0);
     
205.         if (FD_ISSET(Mysock.DaemonSock, &rfds))
     
206.                 SockMsg.AcceptNum = 1; /* some client call server. */
     
207. 
     
208.         for (i=0; i<64; i++) /* Data in message */
     
209.         {
     
210.                 if ((Mysock.Sockets > 0) && (FD_ISSET(Mysock.Sockets, &rfds)))
     
211.                 SockMsg.ReadQueue[SockMsg.ReadNum++] = i;
     
212.         }
     
213. 
     
214.         for (i=0; i<64; i++) /* Data out ready message */
     
215.         {
     
216.                 if ((Mysock.Sockets > 0) && (FD_ISSET(Mysock.Sockets, &wfds)))
     
217.                 SockMsg.WriteQueue[SockMsg.WriteNum++] = i;
     
218.         }
     
219. 
     
220.         if (FD_ISSET(Mysock.DaemonSock, &efds))
     
221.                 SockMsg.AcceptNum = -1; /* server socket error. */
     
222. 
     
223.         for (i=0; i<64; i++) /* Error message */
     
224.         {
     
225.                 if ((Mysock.Sockets > 0) && (FD_ISSET(Mysock.Sockets, &efds)))
     
226.                 SockMsg.ExceptQueue[SockMsg.ExceptNum++] = i;
     
227.         }
     
228.        
     
229.         return(retcode);
     
230. }
     
231. 
     
232. int SendPacket(int Sockno, void *buf, int len)
     
233. /* Send a packet. If succeed return the number of send data, else return -1 */
     
234. {
     
235.         int actlen;
     
236.         if ((Sockno >= 64) || (Sockno < 0) || (Mysock.Sockets[Sockno] == 0))
     
237.                 return(0);
     
238. 
     
239.         if ((actlen = send(Mysock.Sockets[Sockno], buf, len, 0)) < 0)
     
240.                 return(-1);
     
241.        
     
242.         return(actlen);
     
243. }
     
244. 
     
245. int RecvPacket(int Sockno, void *buf, int size)
     
246. /* Receive a packet. If succeed return the number of receive data, else if the connection
     
247.    is shutdown by peer then return 0, otherwise return 0-errno */
     
248. {
     
249.         int actlen;
     
250.         if ((Sockno >= 64) || (Sockno < 0) || (Mysock.Sockets[Sockno] == 0))
     
251.                 return(0);
     
252.        
     
253.         if ((actlen = recv(Mysock.Sockets[Sockno], buf, size, 0)) < 0)
     
254.                 return(0-errno);
     
255.        
     
256.         return(actlen); /* actlen是接收的数据长度,如果为零,指示连接被对方关闭.*/
     
257. }
     

复制代码

yufeng8552

黄叶兄，发错了版区了，不好意思
希望转到程序设计区，拜托
……
thx

libinary

->tcpsock.h:17:28: sys/netinet/in.h: 没有那个文件或目录
->tcpsock.h:18:29: sys/netinet/tcp.h: 没有那个文件或目录
应该是netinet/xx.h，没有sys/

->tcpsock.c:142: warning: passing arg 2 of `accept' from incompatible pointer type
accept的第二个参数是struct sockaddr *，应该转换一下

->tcpsock.c:256:2: warning: no newline at end of file
文件最后应该有个换行符

其它的还没搞清，能不能把tcpsock.h贴出来看看？

kj501

请楼主贴代码时注意保证代码缩进，以便阅读。方法可以在置顶的贴子中找到。

yufeng8552

/*  tcpsock.h包括socket程序经常用到的系统头文件,
    并定义了我们自己的两个数据结构及其实例变量，以及我们提供的函数说明.*/

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/tape.h>-------------编译时期说没有tape.h这个文件
#include <sys/signal.h>
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/netinet/in.h>-----------编译时期说没有这个文件
#include <sys/netinet/tcp.h>------------编译时期说没有这个文件
#include <arpa/inet.h>
#include <netdb.h>

typedef struct SocketsMsg{ /* 套接字消息结构 */
        int AcceptNum; /* 指示是否有外来连接等待接收 */
        int ReadNum; /* 有外来数据等待读取的连接数 */
        int ReadQueue[32]; /* 有外来数据等待读取的连接队列 */
        int WriteNum; /* 可以发送数据的连接数 */
        int WriteQueue[32]; /* 可以发送数据的连接队列 */
        int ExceptNum; /* 有例外的连接数 */
        int ExceptQueue[32]; /* 有例外的连接队列 */
}SocketsMsg;

typedef struct Sockets { /* 套接字结构 */
        int DaemonSock; /* 主套接字 */
        int SockNum; /* 数据套接字数目 */
        int Sockets[64]; /* 数据套接字数组 */
        fd_set readfds, writefds, exceptfds; /* 要被检测的可读、可写、例外的套接字集合 */
        int Port; /* 端口号 */
}Sockets;

Sockets Mysock; /* 全局变量 */
SocketsMsg SockMsg;

int InitSocketsStruct(char * servicename) ;
int InitPassiveSock(char * servicename) ;
void CloseMainSock();
int CreateConnection(struct in_addr *sin_addr);
int AcceptConnection(struct in_addr *IPaddr);
int CloseConnection(int Sockno);
int QuerySocketsMsg();
int SendPacket(int Sockno, void *buf, int len);
int RecvPacket(int Sockno, void *buf, int size);

client.c
/* 客户程序在执行时，先初始化数据结构，然后等待用户输入命令。它识别四个命令：
   conn(ect)： 和服务器建立连接；
   send： 给指定连接发送数据；
   clos(e)： 关闭指定连接；
   quit： 退出客户程序。
*/

#include "tcpsock.h"

main(argc, argv)
int argc;
char **argv;
{
        char cmd_buf[16];
        struct in_addr sin_addr;
        int sockno1, retcode;
        char *buf = "This is a string for test.";

        sin_addr.s_addr = inet_addr("166.111.5.249"); /* 运行服务器程序的主机的IP地址 */

        if ((retcode = InitSocketsStruct("TestService")) < 0)  /* 初始化数据结构 */
        {
                printf("InitSocketsStruct: error code = %d\n", retcode);
                exit(1);
        }

        while (1)
        {
                printf(">");
                gets(cmd_buf);
                if (!strncmp(cmd_buf, "conn", 4))
                {
                        retcode = CreateConnection(&sin_addr); /* 建立连接 */
                        printf("return code: %d\n", retcode);
                }
       
                else if(!strncmp(cmd_buf, "send", 4))
                {
                        printf("Sockets Number:");
                        scanf("%d", &sockno1);
                        retcode = SendPacket(sockno1, buf, 26); /* 发送数据 */
                        printf("return code: %d\n", retcode, sizeof(buf));
                }
               
                else if (!strncmp(cmd_buf, "close", 4))
                {
                        printf("Sockets Number:");
                        scanf("%d", &sockno1);
                        retcode = CloseConnection(sockno1); /* 关闭连接 */
                        printf("return code: %d\n", retcode);
                }

                else if (!strncmp(cmd_buf, "quit", 4))
                        exit(0);
       
                else
                        putchar(\007);
        } /* end while */
}

server.c
/* File Name: server.c */
/* 这是一个很简单的重复服务器程序,它初始化好被动套接字后,循环等待接收连接.如果接收到连接,
   它显示数据套接字序号和客户端的IP地址；如果数据套接字上有数据到来,它接收数据并显示该连接的数据套接字序号和接收到的字符串.*/

#include "tcpsock.h"

main(argc, argv)
int argc;
char **argv;
{
        struct in_addr sin_addr;
        int retcode, i;
        char buf[32];
        /* 对于服务器程序,它经常是处于无限循环状态,只有在用户主动kill该进程或系统关机时,它才结束.
           对于使用kill强行终止的服务器程序,由于主套接字没有关闭,资源没有主动释放,可能会给随后的
           服务器程序重新启动产生影响.因此,主动关闭主套接字是一个良好的变成习惯.下面的语句使程序
           在接收到SIGINT、SIGQUIT和SIGTERM等信号时先执行CloseMainSock()函数关闭主套接字,
           然后再结束程序.因此,在使用kill强行终止服务器进程时,应该先使用kill -2 PID给服务器程序
           一个消息使其关闭主套接字,然后在用kill -9 PID强行结束该进程.*/
       
        (void) signal(SIGINT, CloseMainSock);
        (void) signal(SIGQUIT, CloseMainSock);
        (void) signal(SIGTERM, CloseMainSock);

        if ((retcode = InitPassiveSock("TestService")) < 0)
        {
                printf("InitPassiveSock: error code = %d\n", retcode);
                exit(-1);
        }
       
        while (1)
        {
                retcode = QuerySocketsMsg(); /* 查询网络消息 */
                if (SockMsg.AcceptNum == 1) /* 有外来连接等待接收？*/
                {
                        retcode = AcceptConnection(&sin_addr);
                        printf("retcode = %d, IP = %s \n", retcode, inet_ntoa(sin_addr.s_addr));
                }
                else if (SockMsg.AcceptNum == -1) /* 主套接字错误？*/
                        printf("Daemon Sockets error.\n");

                for (i=0; i<SockMsg.ReadNum; i++) /* 接收外来数据 */
                {
                        if ((retcode = RecvPacket(SockMsg.ReadQueue, buf, 32)) > 0)
                                printf("sockno %d Recv string = %s \n", SockMsg.ReadQueue, buf);
                        else /* 返回数据长度为零,指示连接中断,关闭套接字.*/
                                CloseConnection(SockMsg.ReadQueue);
                }
        } /* end while */
}

yufeng8552

->tcpsock.h:17:28: sys/netinet/in.h: 没有那个文件或目录
->tcpsock.h:18:29: sys/netinet/tcp.h: 没有那个文件或目录
应该是netinet/xx.h，没有sys/

上面文件路径老兄说得很对

->tcpsock.c:142: warning: passing arg 2 of `accept' from incompatible pointer type
accept的第二个参数是struct sockaddr *，应该转换一下

这个问题老兄的方法我试验了，不行，运行出现错误，不认识struct关键字

->tcpsock.c:256:2: warning: no newline at end of file
文件最后应该有个换行符

换行符的问题也很对，还是很谢谢老兄，希望能指出更多的错误

libinary

->tcpsock.c:130: incompatible types in assignment
Mysock.Sockets = tmpsock;
这一行，Mysock.Sockets类型是int [64]，tmpsock是int，类型不符

->tcpsock.c:209: invalid operands to binary /
->tcpsock.c:215: invalid operands to binary /
->tcpsock.c:224: invalid operands to binary /
都是一样的类型错误，要求的是int但提供的是指针，
Mysock.Sockets是int数组的首地址。