检查对方主机是否开机！

fy201314

在c语言上实现这个目的
1、可以调用ping命令来检查；我不想用这个
2、还可以自己写一个包发送到对方ip检测，但是我不会，看了ping.c的源代码我也没有搞懂，希望有人给我写个程序，帮个忙啊 谢谢！

fy201314

还有其它办法啊！
改写 ping命令可以吗？？

fy201314

还有其它办法啊！
改写 ping命令可以吗？？

fy201314

可以用这个命令吗：

1. sendto(int sockfd, void *buff, size nbytes, int flags, const struct sockaddr *to, socklen_t *addrlen);

复制代码

1. if ( sendto(sock, buf, 64, 0, (struct sockaddr *)&it,sizeof(it) ) < 0)
   
2.          {  
   
3.       perror("send failed");  
   
4.       exit(6);  
   
5.       }  
   

复制代码

我不知道这个sockaddr 怎么定义的，可以帮个忙吗？
我现在想检查10.156.10 .1是不是开机，不知道现在怎么写！

无双

不可以
因为上面那个是UDP

便是如果对方的端口没有打开的话也会出错

所以最好还是使用icmp包检测

使用arp也可以

无双

以下是一个实现的源码
可以根据自己需要进行修改

1. 
   
2. //
   
3. // PING.C -- Ping program using ICMP and RAW Sockets
   
4. //
   
5. 
   
6. #include <stdio.h>;
   
7. #include <stdlib.h>;
   
8. #include <winsock.h>;
   
9. 
   
10. #include "ping.h"
    
11. 
    
12. // Internal Functions
    
13. void Ping(LPCSTR pstrHost);
    
14. void ReportError(LPCSTR pstrFrom);
    
15. int  WaitForEchoReply(SOCKET s);
    
16. u_short in_cksum(u_short *addr, int len);
    
17. 
    
18. // ICMP Echo Request/Reply functions
    
19. int                SendEchoRequest(SOCKET, LPSOCKADDR_IN);
    
20. DWORD        RecvEchoReply(SOCKET, LPSOCKADDR_IN, u_char *);
    
21. 
    
22. 
    
23. // main()
    
24. void main(int argc, char **argv)
    
25. {
    
26.     WSADATA wsaData;
    
27.     WORD wVersionRequested = MAKEWORD(1,1);
    
28.     int nRet;
    
29. 
    
30.         // Check arguments
    
31.     if (argc != 2)
    
32.     {
    
33.                 fprintf(stderr,"\nUsage: ping hostname\n");
    
34.                 return;
    
35.     }
    
36. 
    
37.         // Init WinSock
    
38.     nRet = WSAStartup(wVersionRequested, &wsaData);
    
39.     if (nRet)
    
40.     {
    
41.                 fprintf(stderr,"\nError initializing WinSock\n");
    
42.                 return;
    
43.     }
    
44. 
    
45.         // Check version
    
46.         if (wsaData.wVersion != wVersionRequested)
    
47.         {
    
48.                 fprintf(stderr,"\nWinSock version not supported\n");
    
49.                 return;
    
50.         }
    
51. 
    
52.         // Go do the ping
    
53.         Ping(argv[1]);
    
54. 
    
55.         // Free WinSock
    
56.     WSACleanup();
    
57. }
    
58. 
    
59. 
    
60. // Ping()
    
61. // Calls SendEchoRequest() and
    
62. // RecvEchoReply() and prints results
    
63. void Ping(LPCSTR pstrHost)
    
64. {
    
65.         SOCKET          rawSocket;
    
66.         LPHOSTENT lpHost;
    
67.         struct    sockaddr_in saDest;
    
68.         struct    sockaddr_in saSrc;
    
69.         DWORD          dwTimeSent;
    
70.         DWORD          dwElapsed;
    
71.         u_char    cTTL;
    
72.         int       nLoop;
    
73.         int       nRet;
    
74. 
    
75.         // Create a Raw socket
    
76.         rawSocket = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
    
77.         if (rawSocket == SOCKET_ERROR)
    
78.         {
    
79.                 ReportError("socket()");
    
80.                 return;
    
81.         }
    
82.        
    
83.         // Lookup host
    
84.         lpHost = gethostbyname(pstrHost);
    
85.         if (lpHost == NULL)
    
86.         {
    
87.                 fprintf(stderr,"\nHost not found: %s\n", pstrHost);
    
88.                 return;
    
89.         }
    
90.        
    
91.         // Setup destination socket address
    
92.         saDest.sin_addr.s_addr = *((u_long FAR *) (lpHost->;h_addr));
    
93.         saDest.sin_family = AF_INET;
    
94.         saDest.sin_port = 0;
    
95. 
    
96.         // Tell the user what we're doing
    
97.         printf("\nPinging %s [%s] with %d bytes of data:\n",
    
98.                                 pstrHost,
    
99.                                 inet_ntoa(saDest.sin_addr),
    
100.                                 REQ_DATASIZE);
     
101. 
     
102.         // Ping multiple times
     
103.         for (nLoop = 0; nLoop < 4; nLoop++)
     
104.         {
     
105.                 // Send ICMP echo request
     
106.                 SendEchoRequest(rawSocket, &saDest);
     
107. 
     
108.                 // Use select() to wait for data to be received
     
109.                 nRet = WaitForEchoReply(rawSocket);
     
110.                 if (nRet == SOCKET_ERROR)
     
111.                 {
     
112.                         ReportError("select()");
     
113.                         break;
     
114.                 }
     
115.                 if (!nRet)
     
116.                 {
     
117.                         printf("\nTimeOut");
     
118.                         break;
     
119.                 }
     
120. 
     
121.                 // Receive reply
     
122.                 dwTimeSent = RecvEchoReply(rawSocket, &saSrc, &cTTL);
     
123. 
     
124.                 // Calculate elapsed time
     
125.                 dwElapsed = GetTickCount() - dwTimeSent;
     
126.                 printf("\nReply from: %s: bytes=%d time=%ldms TTL=%d",
     
127.                inet_ntoa(saSrc.sin_addr),
     
128.                            REQ_DATASIZE,
     
129.                dwElapsed,
     
130.                cTTL);
     
131.         }
     
132.         printf("\n");
     
133.         nRet = closesocket(rawSocket);
     
134.         if (nRet == SOCKET_ERROR)
     
135.                 ReportError("closesocket()");
     
136. }
     
137. 
     
138. 
     
139. // SendEchoRequest()
     
140. // Fill in echo request header
     
141. // and send to destination
     
142. int SendEchoRequest(SOCKET s,LPSOCKADDR_IN lpstToAddr)
     
143. {
     
144.         static ECHOREQUEST echoReq;
     
145.         static nId = 1;
     
146.         static nSeq = 1;
     
147.         int nRet;
     
148. 
     
149.         // Fill in echo request
     
150.         echoReq.icmpHdr.Type                = ICMP_ECHOREQ;
     
151.         echoReq.icmpHdr.Code                = 0;
     
152.         echoReq.icmpHdr.Checksum        = 0;
     
153.         echoReq.icmpHdr.ID                        = nId++;
     
154.         echoReq.icmpHdr.Seq                        = nSeq++;
     
155. 
     
156.         // Fill in some data to send
     
157.         for (nRet = 0; nRet < REQ_DATASIZE; nRet++)
     
158.                 echoReq.cData[nRet] = ' '+nRet;
     
159. 
     
160.         // Save tick count when sent
     
161.         echoReq.dwTime                                = GetTickCount();
     
162. 
     
163.         // Put data in packet and compute checksum
     
164.         echoReq.icmpHdr.Checksum = in_cksum((u_short *)&echoReq, sizeof(ECHOREQUEST));
     
165. 
     
166.         // Send the echo request                                                                    
     
167.         nRet = sendto(s,                                                /* socket */
     
168.                                  (LPSTR)&echoReq,                        /* buffer */
     
169.                                  sizeof(ECHOREQUEST),
     
170.                                  0,                                                        /* flags */
     
171.                                  (LPSOCKADDR)lpstToAddr, /* destination */
     
172.                                  sizeof(SOCKADDR_IN));   /* address length */
     
173. 
     
174.         if (nRet == SOCKET_ERROR)
     
175.                 ReportError("sendto()");
     
176.         return (nRet);
     
177. }
     
178. 
     
179. 
     
180. // RecvEchoReply()
     
181. // Receive incoming data
     
182. // and parse out fields
     
183. DWORD RecvEchoReply(SOCKET s, LPSOCKADDR_IN lpsaFrom, u_char *pTTL)
     
184. {
     
185.         ECHOREPLY echoReply;
     
186.         int nRet;
     
187.         int nAddrLen = sizeof(struct sockaddr_in);
     
188. 
     
189.         // Receive the echo reply       
     
190.         nRet = recvfrom(s,                                        // socket
     
191.                                         (LPSTR)&echoReply,        // buffer
     
192.                                         sizeof(ECHOREPLY),        // size of buffer
     
193.                                         0,                                        // flags
     
194.                                         (LPSOCKADDR)lpsaFrom,        // From address
     
195.                                         &nAddrLen);                        // pointer to address len
     
196. 
     
197.         // Check return value
     
198.         if (nRet == SOCKET_ERROR)
     
199.                 ReportError("recvfrom()");
     
200. 
     
201.         // return time sent and IP TTL
     
202.         *pTTL = echoReply.ipHdr.TTL;
     
203.         return(echoReply.echoRequest.dwTime);                  
     
204. }
     
205. 
     
206. // What happened?
     
207. void ReportError(LPCSTR pWhere)
     
208. {
     
209.         fprintf(stderr,"\n%s error: %d\n",
     
210.                 WSAGetLastError());
     
211. }
     
212. 
     
213. 
     
214. // WaitForEchoReply()
     
215. // Use select() to determine when
     
216. // data is waiting to be read
     
217. int WaitForEchoReply(SOCKET s)
     
218. {
     
219.         struct timeval Timeout;
     
220.         fd_set readfds;
     
221. 
     
222.         readfds.fd_count = 1;
     
223.         readfds.fd_array[0] = s;
     
224.         Timeout.tv_sec = 5;
     
225.     Timeout.tv_usec = 0;
     
226. 
     
227.         return(select(1, &readfds, NULL, NULL, &Timeout));
     
228. }
     
229. 
     
230. 
     
231. //
     
232. // Mike Muuss' in_cksum() function
     
233. // and his comments from the original
     
234. // ping program
     
235. //
     
236. // * Author -
     
237. // *        Mike Muuss
     
238. // *        U. S. Army Ballistic Research Laboratory
     
239. // *        December, 1983
     
240. 
     
241. /*
     
242. *                        I N _ C K S U M
     
243. *
     
244. * Checksum routine for Internet Protocol family headers (C Version)
     
245. *
     
246. */
     
247. u_short in_cksum(u_short *addr, int len)
     
248. {
     
249.         register int nleft = len;
     
250.         register u_short *w = addr;
     
251.         register u_short answer;
     
252.         register int sum = 0;
     
253. 
     
254.         /*
     
255.          *  Our algorithm is simple, using a 32 bit accumulator (sum),
     
256.          *  we add sequential 16 bit words to it, and at the end, fold
     
257.          *  back all the carry bits from the top 16 bits into the lower
     
258.          *  16 bits.
     
259.          */
     
260.         while( nleft >; 1 )  {
     
261.                 sum += *w++;
     
262.                 nleft -= 2;
     
263.         }
     
264. 
     
265.         /* mop up an odd byte, if necessary */
     
266.         if( nleft == 1 ) {
     
267.                 u_short        u = 0;
     
268. 
     
269.                 *(u_char *)(&u) = *(u_char *)w ;
     
270.                 sum += u;
     
271.         }
     
272. 
     
273.         /*
     
274.          * add back carry outs from top 16 bits to low 16 bits
     
275.          */
     
276.         sum = (sum >;>; 16) + (sum & 0xffff);        /* add hi 16 to low 16 */
     
277.         sum += (sum >;>; 16);                        /* add carry */
     
278.         answer = ~sum;                                /* truncate to 16 bits */
     
279.         return (answer);
     
280. }
     
281. 
     

复制代码