linux获取本机IP地址问题(live555)

1.问题 :今天在一台服务器上安装live555,运行结果如下:

 
出现ip地址为:0.0.0.0
2.最后问题所在:
以后要注意一点就是:别从别人身上找问题,应该从自己身上找问题!不扯了。最后发现是在防火墙配置里面有问题,发现:
 

信任的设备中居然没有eth0。于是选择上即可,同时加上端口554.运行木有问题!

3.linux获取本机IP地址的方法

转发与:http://jeremiah.blog.51cto.com/539865/275791

 

live555MediaServer读取本地IP的主要方法是:发送一个TTL=0的组播包,接收这个包,然后解析发送地址,即为本机地址。
 
        这种方法只能获得本机的最主要的IP地址(eth0)。不能获取所有的IP地址。
 
        抠取代码如下,操作平台为RedHat Linux ES5,gcc 4.1.2。

 

   
   
   
   
  1. /*******************************************************************************  
  2.  * Filename:        get_ip.c  
  3.  * Created on:      Feb 8, 2010  
  4.  * Author:          Jeremiah  
  5.  * Description:     获取本机IP地址  
  6.  *  
  7.  ******************************************************************************/ 
  8.  
  9. #include   
  10. #include   
  11. #include   
  12. #include   
  13. #include   
  14. #include   
  15. #include   
  16. #include   
  17. #include   
  18. #include   
  19.  
  20. in_addr_t ourIPAddress();  
  21. int setupDatagramSocket(uint16_t);  
  22. uint8_t socketJoinGroup(int socket, uint32_t groupAddress);  
  23. uint8_t writeSocket(int socket, struct in_addr address, uint32_t port,  
  24.         uint8_t ttlArg, unsigned char *buffer, unsigned bufferSize);  
  25. int readSocket(int socket, unsigned char *buffer, unsigned bufferSize,  
  26.         struct sockaddr_in *fromAddress, struct timeval *timeout);  
  27. int blockUntilReadable(int socket, struct timeval* timeout);  
  28. uint8_t badAddress(uint32_t addr);  
  29. uint8_t socketLeaveGroup(int socket, uint32_t groupAddress);  
  30. uint8_t IsMulticastAddress(uint32_t address);  
  31.  
  32. #define SET_SOCKADDR_SIN_LEN(var)  
  33. #define MAKE_SOCKADDR_IN(var,adr,prt) /*adr,prt must be in network order*/\  
  34.     struct sockaddr_in var;\  
  35.     var.sin_family = AF_INET;\  
  36.     var.sin_addr.s_addr = (adr);\  
  37.     var.sin_port = (prt);\  
  38.     SET_SOCKADDR_SIN_LEN(var);  
  39.  
  40. int main(int argc, char **argv) {  
  41.     struct sockaddr_in ourAddress;  
  42.     ourAddress.sin_addr.s_addr = ourIPAddress();  
  43.  
  44.     if (ourAddress.sin_addr.s_addr == 0) {  
  45.         printf("get local ip error!\n");  
  46.         return 1;  
  47.     }  
  48.  
  49.     printf("%s\n", inet_ntoa(ourAddress.sin_addr));  
  50.  
  51.     return 0;  
  52. }  
  53.  
  54. in_addr_t ourIPAddress() {  
  55.     uint32_t ourAddress = 0;  
  56.     int sock = -1;  
  57.     struct in_addr testAddr;  
  58.     struct sockaddr_in fromAddr;  
  59.     fromAddr.sin_addr.s_addr = 0;  
  60.  
  61.     // Get our address by sending a (0-TTL) multicast packet,  
  62.     // receiving it, and looking at the source address used.  
  63.     // (This is kinda bogus, but it provides the best guarantee  
  64.     // that other nodes will think our address is the same as we do.)  
  65.     testAddr.s_addr = inet_addr("228.67.43.92");  
  66.     uint16_t testPort = 15948;  
  67.     sock = setupDatagramSocket(testPort);  
  68.     if (sock < 0) {  
  69.         return 0;  
  70.     }  
  71.  
  72.     if (!socketJoinGroup(sock, testAddr.s_addr)) {  
  73.         return 0;  
  74.     }  
  75.  
  76.     unsigned char testString[] = "hostIdTest";  
  77.     unsigned testStrLength = sizeof(testString);  
  78.     if (!writeSocket(sock, testAddr, testPort, 0, testString, testStrLength)) {  
  79.         return 0;  
  80.     }  
  81.  
  82.     unsigned char readBuffer[20];  
  83.     struct timeval timeout;  
  84.     timeout.tv_sec = 5;  
  85.     timeout.tv_usec = 0;  
  86.  
  87.     int bytesRead = readSocket(sock, readBuffer, sizeof(readBuffer), &fromAddr,  
  88.             &timeout);  
  89.     if (bytesRead == 0 // timeout occurred  
  90.             || bytesRead != (int) testStrLength || strncmp(  
  91.             (char *) readBuffer, (char *) testString, testStrLength) != 0) {  
  92.         printf("read socket error\n");  
  93.         return 0;  
  94.     }  
  95.  
  96.     uint32_t from = fromAddr.sin_addr.s_addr;  
  97.     if (badAddress(from)) {  
  98.         printf("This computer has an invalid IP address: 0x%x\n",  
  99.                 (uint32_t) (ntohl(from)));  
  100.         from = 0;  
  101.     }  
  102.  
  103.     ourAddress = from;  
  104.  
  105.     if (sock >= 0) {  
  106.         socketLeaveGroup(sock, testAddr.s_addr);  
  107.         close(sock);  
  108.     }  
  109.  
  110.     return ourAddress;  
  111. }  
  112.  
  113. int setupDatagramSocket(uint16_t port) {  
  114.     int reuseFlag = 1;  
  115.     int newSocket = socket(AF_INET, SOCK_DGRAM, 0);  
  116.     const uint8_t loop = 1;  
  117.  
  118.     if (newSocket < 0) {  
  119.         printf("unable to create datagram socket\n");  
  120.         return newSocket;  
  121.     }  
  122.  
  123.     if (setsockopt(newSocket, SOL_SOCKET, SO_REUSEADDR,  
  124.             (const char *) &reuseFlag, sizeof(reuseFlag)) < 0) {  
  125.         printf("setsockopt(SO_REUSEADDR) error!\n");  
  126.         close(newSocket);  
  127.         return -1;  
  128.     }  
  129.  
  130.     if (setsockopt(newSocket, IPPROTO_IP, IP_MULTICAST_LOOP,  
  131.             (const char*) &loop, sizeof(loop)) < 0) {  
  132.         printf("setsockopt(IP_MULTICAST_LOOP) error!\n");  
  133.         close(newSocket);  
  134.         return -1;  
  135.     }  
  136.  
  137.     uint32_t addr = INADDR_ANY;  
  138.     MAKE_SOCKADDR_IN(name, addr, port);  
  139.  
  140.     if (bind(newSocket, (struct sockaddr *) &name, sizeof(name)) != 0) {  
  141.         printf("bind() error (port number: %d)!\n", ntohs(port));  
  142.         close(newSocket);  
  143.         return -1;  
  144.     }  
  145.  
  146.     return newSocket;  
  147. }  
  148.  
  149. uint8_t socketJoinGroup(int socket, uint32_t groupAddress) {  
  150.     if (!IsMulticastAddress(groupAddress)) {  
  151.         return 1; // ignore this case  
  152.     }  
  153.  
  154.     struct ip_mreq imr;  
  155.     imr.imr_multiaddr.s_addr = groupAddress;  
  156.     imr.imr_interface.s_addr = INADDR_ANY;  
  157.     if (setsockopt(socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char *) &imr,  
  158.             sizeof(struct ip_mreq)) < 0) {  
  159.         printf("setsockopt(IP_ADD_MEMBERSHIP) error!\n");  
  160.         return 0;  
  161.     }  
  162.  
  163.     return 1;  
  164. }  
  165.  
  166.  
  167. uint8_t writeSocket(int socket, struct in_addr address, uint32_t port,  
  168.         uint8_t ttlArg, unsigned char *buffer, unsigned bufferSize) {  
  169.     if (ttlArg != 0) {  
  170.         // Before sending, set the socket's TTL:  
  171.         uint8_t ttl = ttlArg;  
  172.         if (setsockopt(socket, IPPROTO_IP, IP_MULTICAST_TTL,  
  173.                 (const char *) &ttl, sizeof(ttl)) < 0) {  
  174.             printf("setsockopt(IP_MULTICAST_TTL) error!");  
  175.             return 0;  
  176.         }  
  177.     }  
  178.     MAKE_SOCKADDR_IN(dest, address.s_addr, port);  
  179.     int bytesSent = sendto(socket, (char *) buffer, bufferSize, 0,  
  180.             (struct sockaddr *) &dest, sizeof(dest));  
  181.     if (bytesSent != (int) bufferSize) {  
  182.         printf("writeSocket(%d), sendTo() error: wrote " 
  183.                 "%d bytes instead of %u!\n", socket, bytesSent, bufferSize);  
  184.         return 0;  
  185.     }  
  186.  
  187.     return 1;  
  188. }  
  189.  
  190. int readSocket(int socket, unsigned char *buffer, unsigned int bufferSize,  
  191.         struct sockaddr_in *fromAddress, struct timeval *timeout) {  
  192.     int bytesRead = -1;  
  193.  
  194.     int result = blockUntilReadable(socket, timeout);  
  195.     if (timeout != NULL && result == 0) {  
  196.         bytesRead = 0;  
  197.         return -1;  
  198.     } else if (result <= 0) {  
  199.         return -1;  
  200.     }  
  201.  
  202.     socklen_t addressSize = (socklen_t) sizeof(struct sockaddr_in);  
  203.     bytesRead = recvfrom(socket, (char *) buffer, bufferSize, 0,  
  204.             (struct sockaddr *) fromAddress, &addressSize);  
  205.     if (bytesRead < 0) {  
  206.         printf("recvfrom() error!\n");  
  207.         return -1;  
  208.     }  
  209.  
  210.     return bytesRead;  
  211. }  
  212.  
  213. int blockUntilReadable(int socket, struct timeval *timeout) {  
  214.     int result = -1;  
  215.     fd_set rd_set;  
  216.     FD_ZERO(&rd_set);  
  217.     if (socket < 0)  
  218.         return -1;  
  219.     FD_SET((unsigned) socket, &rd_set);  
  220.     const unsigned numFds = socket + 1;  
  221.  
  222.     result = select(numFds, &rd_set, NULL, NULL, timeout);  
  223.     if (timeout != NULL && result == 0) {  
  224.         printf("select timeout!\n");  
  225.         return -1; // this is OK - timeout occurred  
  226.     } else if (result <= 0) {  
  227.         printf("select() error!\n");  
  228.         return -1;  
  229.     }  
  230.  
  231.     if (!FD_ISSET(socket, &rd_set)) {  
  232.         printf("select() error - !FD_ISSET!\n");  
  233.         return -1;  
  234.     }  
  235.  
  236.     return result;  
  237. }  
  238.  
  239. uint8_t badAddress(uint32_t addr) {  
  240.     // Check for some possible erroneous addresses:  
  241.     uint32_t hAddr = ntohl(addr);  
  242.     return (hAddr == 0x7F000001 /* 127.0.0.1 */ 
  243.     || hAddr == 0 || hAddr == (uint32_t) (~0));  
  244. }  
  245.  
  246. uint8_t socketLeaveGroup(int socket, uint32_t groupAddress) {  
  247.     if (!IsMulticastAddress(groupAddress))  
  248.         return 1; // ignore this case  
  249.  
  250.     struct ip_mreq imr;  
  251.     imr.imr_multiaddr.s_addr = groupAddress;  
  252.     imr.imr_interface.s_addr = INADDR_ANY;  
  253.     if (setsockopt(socket, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const char *) &imr,  
  254.             sizeof(struct ip_mreq)) < 0) {  
  255.         return 0;  
  256.     }  
  257.  
  258.     return 1;  
  259. }  
  260.  
  261. uint8_t IsMulticastAddress(uint32_t address) {  
  262.     // Note: We return False for addresses in the range 224.0.0.0  
  263.     // through 224.0.0.255, because these are non-routable  
  264.     // Note: IPv4-specific #####  
  265.     uint32_t addressInHostOrder = ntohl(address);  
  266.     return addressInHostOrder > 0xE00000FF && addressInHostOrder <= 0xEFFFFFFF;  

 

你可能感兴趣的:(流媒体技术)