开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
network.cc
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：14k
源码类别：

DVD

开发平台：

Unix_Linux

network.cc：源码内容
  1. /*
  2.    File: network.cc
  4.    By: Alex Theo de Jong
  5.    Created: April 1996
  7.    Description:
  8.    This file contains all network functions to be used with the mpeg2player. This
  9.    is a temporary solution. The complete AtmSocket API should be used for this
  10.    in order to use configuration/testing facilities. Hopefully we can do that im
  11.    June/July 1996
  12. */
  14. #ifdef __GNUG__
  15. #pragma implementation
  16. #endif
  18. #include "athread.hh"
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <String.h>
  23. #include <fstream.h>
  24. #include <sys/time.h>
  25. #include <sys/errno.h>
  26. #include <fcntl.h>
  27. #ifdef LINUX
  28. #include <sys/types.h>
  29. #include <sys/socket.h>
  30. #include <sys/poll.h>
  31. //#include <asm/poll.h>
  32. #define POLLRDNORM      0x0040
  34. #endif
  35. #ifdef IRIX
  36. #include <bstring.h>
  37. #include <stropts.h>
  38. #include <poll.h>
  39. #endif
  41. #include "error.hh"
  42. #include "debug.hh"
  43. #include "util.hh"
  45. #include "network.hh"
  49. // Socket File
  51. SocketFile::SocketFile(const char* filen){
  52.   TRACER("SocketFile::SocketFile(const char* filen)");
  53.   filename=filen;
  54.   /*
  55.   file.open(filename.chars());
  56.   if (!file){
  57.     error("could not open file `" << filename << "' for reading");
  58.   }
  59.   */
  60.   if (filen[0] == '-' && filen[1] == '') 
  61.     socketfd = 0;
  62.   else if ((socketfd=open(filename.chars(), O_RDONLY | O_NDELAY))<=0){
  63.     error("could not open file `" << filename << "' for reading");
  64.   }
  65. }
  67. SocketFile::~SocketFile(){
  68.   TRACER("SocketFile::~SocketFile()");
  69.   /*
  70.   if (filename.length()){
  71.     file.close();
  72.   }
  73.   */
  74.   ::close(socketfd);
  75. }
  78. int SocketFile::recv(unsigned char* data, int size){
  79.   DEBUGGER("int SocketFile::recv(unsigned char* data, int size)");
  80.   bfr=data;
  81.   read_bytes=0;
  82.   do {
  83.     /*
  84.     if ((bytes=(file.read(data, size).gcount()))<=0)
  85.     */
  86.     if ((bytes=read(socketfd, bfr, size - read_bytes))<=0)
  88.       return bytes;
  89.     bfr+=bytes;
  90.     read_bytes+=bytes;
  91.   }
  92.   while (read_bytes<size);
  93.   return read_bytes;
  94. };
  97. int SocketFile::close(){
  98.   TRACER("int SocketFile::close()");
  99.   if (filename.length() && socketfd>=0){
  100.     return ::close(socketfd);
  101.   }
  102.   return -1;
  103. }
  105. // Socket TCP
  107. SocketTcp::SocketTcp(unsigned int asap, unsigned int pdu_size){
  108.   TRACER("SocketTcp::SocketTcp(unsigned int asap, unsigned int pdu_size)");
  110.   sockaddr_in server_addr;
  111.   
  112.   if ((socketfd=::socket(AF_INET, SOCK_STREAM, IPPROTO_IP))<0){
  113.     error("can't open stream socket");
  114.     exit(1);
  115.   }
  116.   
  117. #if (defined(IRIX) || defined(IRIX_PTHREAD))
  118.   bzero(&server_addr, sizeof(server_addr));
  119. #else
  120.   memset((char*) &server_addr, 0, sizeof(server_addr));
  121. #endif
  122.   
  123. #ifdef SOLARIS
  124.   struct hostent* host=0;
  126.   // Try ATM
  127.   String name(getenv("HOSTNAME"));
  128.   name+="-atm";  // default extension for ATM
  129.   if (name.length()!=0 && (host=gethostbyname(name.chars()))==0){
  130.     // if no ATM, try regular HOSTNAME address
  131.     if ((host=gethostbyname(getenv("HOSTNAME")))==0){
  132.       error("could not get host by name");
  133.       athr_exit(0);
  134.     }
  135.   }
  137.   server_addr.sin_addr.s_addr =((struct in_addr *) host->h_addr_list[0])->s_addr;
  138. #endif
  139.   
  140.   server_addr.sin_family=AF_INET;
  141.   server_addr.sin_port=htons(asap);
  142.   while (1){
  143.     if (::bind(socketfd, (struct sockaddr*) &server_addr, sizeof(server_addr))<0){
  144.       ::close(socketfd);
  145.       error("could not bind local address");
  146.       exit(1);
  147.     }
  148.     else break;
  149.     asap++;
  150.   }
  151.   
  152.   int reuseaddr=1;
  153.   if (setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR, (char*) &reuseaddr, sizeof(reuseaddr))<0){
  154.     error("can't set sender socket option (SO_REUSEADDR)"); exit(1);
  155.   }
  156.   
  157.   if (pdu_size){
  158.     unsigned int read_size=pdu_size;
  159.     if (setsockopt(socketfd,SOL_SOCKET,SO_SNDBUF,(char*)&read_size,sizeof(read_size))<0){
  160.       error("can't set socket option (SO_SNDBUF)"); exit(1);
  161.     }
  162.     if (setsockopt(socketfd,SOL_SOCKET,SO_RCVBUF,(char*)&read_size,sizeof(read_size))<0){
  163.       error("can't set socket option (SO_RCVBUF)"); exit(1);
  164.     }
  165.   }
  166.   
  167.   int alive=1;
  168.   if (setsockopt(socketfd,SOL_SOCKET,SO_KEEPALIVE,(char*)&alive,sizeof(alive))<0){
  169.     error("can't set socket option (SO_KEEPALIVE)"); exit(1);
  170.   }
  171.   int error=0;
  172. #ifdef LINUX
  173.   socklen_t error_len=sizeof(error);
  174. #else
  175.   int  error_len=sizeof(error);
  176. #endif
  177.   if (getsockopt(socketfd, SOL_SOCKET, SO_ERROR, (char*) &error, &error_len)<0){
  178.     error("can't get sender socket option (SO_ERROR)"); exit(1);
  179.   }
  180.   
  181.   if (::listen(socketfd, 1)<0){
  182.     error("could not listen to connection");
  183.     exit(0);
  184.   }
  185. }
  187. SocketTcp::~SocketTcp(){
  188.   TRACER("SocketTcp::~SocketTcp");
  189.   ::close(fd);
  190. }
  192. int SocketTcp::accept(){
  193.   DEBUGGER("int SocketTcp::accept()");
  194.   sockaddr_in client_addr;
  195. #ifdef LINUX  
  196.   socklen_t client_len=sizeof(client_addr);
  197. #else
  198.   int client_len=sizeof(client_addr);
  199. #endif
  200. #if (defined(IRIX) || defined(IRIX_PTHREAD))
  201.   bzero(&client_addr, sizeof(client_addr));
  202. #else
  203.   memset((char*) &client_addr, 0, sizeof(client_addr));
  204. #endif
  205.   
  206.   if ((fd=::accept(socketfd, (struct sockaddr*) &client_addr, &client_len))<=0){
  207.     error("could not accept connection (" << itoa(errno) << ")");
  208.     athr_exit(0);
  209.   }
  210.   ::close(socketfd);
  211.   message("received connection on TCP!");
  212.   
  213.   return fd;
  214. }
  216. int SocketTcp::recv(unsigned char* data, int size){
  217.   DEBUGGER("int SocketTcp::recv(unsigned char* data, int size)");
  218.   bfr=data;
  219.   read_bytes=0;
  220.   do {
  221.     if ((bytes=::read(fd, bfr, size-read_bytes))<=0)
  222.       return bytes;
  223.     bfr+=bytes;
  224.     read_bytes+=bytes;
  225.   }
  226.   while (read_bytes<size);
  227. #ifdef DEEPDEBUG
  228.   static int count=0;
  229.   unsigned int test=((data[0]<<24) | (data[1] << 16) | (data[2]<<8) | data[3]);  printf("First 4 bytes=%xn", test);
  230.   test=((data[188]<<24) | (data[189] << 16) | (data[190]<<8) | data[191]); 
  231.   printf("First 4 bytes=%xn", test);
  232.   if (count++==10) exit(0);
  233. #endif
  234.   return read_bytes;
  235. };
  238. int SocketTcp::close(){
  239.   int err=::close(fd);
  240.   TRACER("int SocketTcp::close()");
  241.   return err;
  242. }
  245. // Socket UDP
  247. SocketUdp::SocketUdp(unsigned int asap, unsigned int pdu_size){
  248.   TRACER("SocketUdp::SocketUdp()");
  250.   sockaddr_in server_addr;
  251.   
  252.   if ((socketfd=::socket(AF_INET, SOCK_DGRAM, IPPROTO_IP))<0){
  253.     error("can't open dgram socket");
  254.     exit(1);
  255.   }
  256.   
  257. #if (defined(IRIX) || defined(IRIX_PTHREAD))
  258.   bzero(&server_addr, sizeof(server_addr));
  259. #else
  260.   memset((char*) &server_addr, 0, sizeof(server_addr));
  261. #endif
  262.   
  263. #ifdef SOLARIS
  264.   struct hostent* host=0;
  265.   //  if (option==1){
  266.   if ((host=gethostbyname(getenv("HOSTNAME")))==0){
  267.     error("could not get host by name");
  268.     athr_exit(0);
  269.   }
  271.   /*
  272.   else {
  273.     String name(getenv("HOSTNAME"));
  274.     name+="-atm";  // default extension for ATM
  275.     if (name.length()!=0 && (host=gethostbyname(name.chars()))==0){
  276.       error("could not get host by name");
  277.       athr_exit(0);
  278.     }
  279.   }
  280.   */
  282.   server_addr.sin_addr.s_addr =((struct in_addr *) host->h_addr_list[0])->s_addr;
  283. #endif
  284.  
  285.   server_addr.sin_family=AF_INET;
  286.   server_addr.sin_port=htons(asap);
  287.   while (1){
  288.     if (::bind(socketfd, (struct sockaddr*) &server_addr, sizeof(server_addr))<0){
  289.       ::close(socketfd);
  290.       error("could not bind local address");
  291.       exit(1);
  292.     }
  293.     else break;
  294.     asap++;
  295.   }
  296.   
  297.   int reuseaddr=1;
  298.   if (setsockopt(socketfd, SOL_SOCKET, SO_REUSEADDR, (char*) &reuseaddr, sizeof(reuseaddr))<0){
  299.     error("can't set sender socket option (SO_REUSEADDR)"); exit(1);
  300.   }
  301.  
  302.   if (pdu_size){
  303.     unsigned int read_size=pdu_size;
  304.     if (setsockopt(socketfd,SOL_SOCKET,SO_SNDBUF,(char*)&read_size,sizeof(read_size))<0){
  305.       error("can't set socket option (SO_SNDBUF)"); exit(1);
  306.     }
  307.     if (setsockopt(socketfd,SOL_SOCKET,SO_RCVBUF,(char*)&read_size,sizeof(read_size))<0){
  308.       error("can't set socket option (SO_RCVBUF)"); exit(1);
  309.     }
  310.   }
  311.   
  312.   int alive=1;
  313.   if (setsockopt(socketfd,SOL_SOCKET,SO_KEEPALIVE,(char*)&alive,sizeof(alive))<0){
  314.     error("can't set socket option (SO_KEEPALIVE)"); exit(1);
  315.   }
  316.   int error=0;
  317. #ifdef LINUX
  318.   socklen_t error_len=sizeof(error);
  319. #else
  320.   int error_len=sizeof(error);
  321. #endif
  322.   if (getsockopt(socketfd, SOL_SOCKET, SO_ERROR, (char*) &error, &error_len)<0){
  323.     error("can't get sender socket option (SO_ERROR)"); exit(1);
  324.   }
  325.  
  326.   pcli_addr=(sockaddr*) &cli_addr;
  327.   cli_len=sizeof(cli_addr);
  328. }
  330. SocketUdp::~SocketUdp(){
  331.   TRACER("SocketUdp::~SocketUdp");
  332.   ::close(fd);
  333. }
  335. int SocketUdp::accept(){
  336.   TRACER("int SocketUdp::accept()");
  337.   fd=socketfd;
  338.   message("received connection on UDP!");
  339.   return fd;
  340. }
  342. int SocketUdp::recv(unsigned char* data, int size){
  343.   DEBUGGER("int SocketUdp::recv(unsigned char* data, int size)");
  344.   bfr=data;
  345.   read_bytes=0;
  346.   do {
  347. #ifdef LINUX
  348.     if ((bytes=::recvfrom(fd, (char*) bfr, size-read_bytes, 0, pcli_addr, (socklen_t*)&cli_len))==size)
  349. #else
  350.     if ((bytes=::recvfrom(fd, (char*) bfr, size-read_bytes, 0, pcli_addr, &cli_len))==size)
  351. #endif
  352.       return bytes;
  353.     bfr+=bytes;
  354.     read_bytes+=bytes;
  355.   } 
  356.   while (read_bytes<size);
  358.   return read_bytes;
  359. }
  361. int SocketUdp::close(){
  362.   int err=::close(fd);
  363.   TRACER("int SocketUdp::close()");
  364.   return err;
  365. }
  369. #ifdef FORE_ATM
  371. // Socket ATM SPANS
  373. SocketAtmSpans::SocketAtmSpans(unsigned int sap) : asap(sap) {
  374.   TRACER("SocketAtmSpans::SocketAtmSpans(unsigned int sap)");
  376.   Atm_info info;
  377.   aal_type=aal_type_5;
  378.   dataflow=duplex;
  379.   
  380.   if ((socketfd=atm_open(ATMDEVICE, O_RDWR, &info))<0){
  381.     atm_error("atm_open : ");
  382.     exit(1);
  383.   }
  384.   
  385.   int queue_size=1;
  386.   if (atm_bind(socketfd, asap, &asap, queue_size)<0){
  387.     atm_error("atm_bind");
  388.     exit(1);
  389.   }
  390. }
  392. SocketAtmSpans::~SocketAtmSpans(){
  393.   TRACER("SocketAtmSpans::~SocketAtmSpans()");
  394.   ::atm_close(fd);
  395. }
  397. int SocketAtmSpans::accept(){
  398.   TRACER("int SocketAtmSpans::accept()");
  399.   Atm_qos qos_server;
  400.   int conn_id(0);
  401.   
  402.   if (atm_listen(socketfd, &conn_id, &atm_endpoint, &qos_server, &aal_type) < 0){
  403.     atm_error("atm_listen");
  404.     exit(1);
  405.   }
  406.   qos.peak_bandwidth.target  = qos_server.peak_bandwidth.target; 
  407.   qos.peak_bandwidth.minimum = qos_server.peak_bandwidth.minimum;
  408.   qos.mean_bandwidth.target  = qos_server.mean_bandwidth.target;
  409.   qos.mean_bandwidth.minimum = qos_server.mean_bandwidth.minimum;
  410.   qos.mean_burst.target      = qos_server.mean_burst.target;
  411.   qos.mean_burst.minimum     = qos_server.mean_burst.minimum;
  412.   
  413.   if (atm_accept(socketfd, socketfd, conn_id, &qos, dataflow) < 0) {
  414.     atm_error("atm_accept");
  415.     exit(1);
  416.   }
  417.   fd=socketfd;
  418.   message("received connection on ATM SPANS!");
  420.   return fd;
  421. }
  423. int SocketAtmSpans::recv(unsigned char* data, int size){
  424.   DEBUGGER("int SocketAtmSpans::recv(unsigned char* data, int size)");
  425.   bfr=data;
  426.   read_bytes=0;
  427.   do {
  428.     if ((bytes=::atm_recv(fd, (caddr_t) bfr, size-read_bytes))<=0)
  429.       // ATM returns -1 when connection is terminated
  430.       return (bytes==-1 || bytes==0) ? 0 : bytes;
  431.     bfr+=bytes;
  432.     read_bytes+=bytes;
  433.   }
  434.   while (read_bytes<size);
  436.   return read_bytes;
  437. }
  439. int SocketAtmSpans::close(){
  440.   int err=::atm_close(fd);
  441.   TRACER("int SocketAtmSpans::close()");
  442.   return err;
  443. }
  447. // class ATM PVC
  449. SocketAtmPvc::SocketAtmPvc(unsigned int vci, unsigned int vpi){
  450.   TRACER("SocketAtmPvc::SocketAtmPvc(unsigned int vci, unsigned int vpi)");
  452.   Atm_info info;
  453.   Atm_conn_resource  qos;
  454.   aal_type=aal_type_5;
  456.   if ((socketfd=atm_open(ATMDEVICE, O_RDWR, &info))<0){
  457.     atm_error("atm_open: ");
  458.     exit(1);
  459.   }
  461.   /*
  462.   if (info.mtu < pdu_size){
  463.     error("sdu size to big for maximum ATM mtu");
  464.     exit(1);
  465.   }
  466.   */
  468.   qos.peak_bandwidth =  50000;  // set some dummy values
  469.   qos.mean_bandwidth =  500000;
  471.   vpvc= (vpi  & 0x00000FFF) << 16;
  472.   vpvc+=(vci & 0x0000FFFF);
  474.   if (atm_bind_pvc(socketfd, vpvc, aal_type, &qos)!=0){
  475.     atm_error("atm_bind_pvc");
  476.     exit(1);
  477.   }
  478. }
  481. SocketAtmPvc::~SocketAtmPvc(){
  482.   TRACER("SocketAtmPvc::~SocketAtmPvc()");
  483.   ::atm_close(fd);
  484. }
  486. int SocketAtmPvc::accept(){
  487.   TRACER("int SocketAtmPvc::accept()");
  489.   fd=socketfd;  // ready to receive data
  490.   message("received connection on ATM PVC!");
  492.   return fd;
  493. }
  495. int SocketAtmPvc::recv(unsigned char* data, int size){
  496.   DEBUGGER("int SocketAtmPvc::recv(unsigned char* data, int size)");
  497.   bfr=data;
  498.   read_bytes=0;
  499.   do {
  500.     if ((bytes=::atm_recvfrom(fd, (caddr_t) bfr, size-read_bytes, &vpvc))<=1){
  501.       if (bytes==1) return 0; // eof   EOF protocol if using a PVC
  502.       return bytes;
  503.     }
  504.     bfr+=bytes;
  505.     read_bytes+=bytes;
  506.   }
  507.   while (read_bytes<size);
  508.   return read_bytes;
  509. }
  510.  
  511. int SocketAtmPvc::close(){
  512.   int err=::atm_close(fd);
  513.   TRACER("int SocketAtmPvc::close()");
  514.   return err;
  515. }
  517. #endif // FORE_ATM
  520. // SocketMulti waits at several ports and accepts the one first activated
  522. SocketMulti::SocketMulti(unsigned int asap, int pdu_size, unsigned int vci, unsigned int vpi){
  523.   TRACER("SocketMulti::SocketMulti(unsigned int asap, int pdu_size, vci, int vpi)");
  525.   sockets=new Socket*[SOCKETMULTI_MAX];
  526.   count=0;
  527.   sockets[count++]=new SocketTcp(asap, pdu_size);
  528.   sockets[count++]=new SocketUdp(asap, pdu_size);
  529. #ifdef FORE_ATM
  530.   // test to find ATM board
  531.   Atm_info info;
  532.   int dummy;
  533.   if ((dummy=atm_open(ATMDEVICE, O_RDWR, &info))>0){
  534.     atm_close(dummy);
  535.     // found an ATM board; thus include these while wating for connection
  536.     sockets[count++]=new SocketAtmSpans(asap);
  537.     sockets[count++]=new SocketAtmPvc(vci, vpi);
  538.   }
  539.   sockets[count]=0;
  540. #endif 
  541. }
  544. SocketMulti::SocketMulti(const char* name){ 
  545.   TRACER("SocketMulti::SocketMulti(const char* name)");
  546.   
  547.   sockets=0;
  548.   socket=new SocketFile(name);
  549.   count=1;
  550. }
  552. SocketMulti::~SocketMulti(){
  553.   if (sockets){
  554.     for (int i=0; sockets[i]!=0; i++) 
  555.       delete sockets[i];
  556.     delete[] sockets;
  557.   }
  558.   else delete socket;
  559. }
  561. int SocketMulti::accept(){
  562.   TRACER("int SocketMulti::accept()");
  563.   if (sockets==0) return 0;
  565.   pollfd fds[SOCKETMULTI_MAX];
  566.   for (int i=0; i<count; i++){
  567.     fds[i].fd=sockets[i]->socketfd;
  568.     fds[i].events= POLLRDNORM | POLLPRI; //  POLLIN | POLLRDBAND | );
  569.   }
  571.   message("waiting for connection ... ");
  573.   if (poll(fds, count, -1)<0){
  574.     error("could not call poll");
  575.     exit(1);
  576.   }
  578.   for (int j=0; j<count; j++){
  579.     if (fds[j].revents>0){
  580.       return (socket=sockets[j])->accept();
  581.     }
  582.   }
  584.   error("failed to find event after poll");
  585.   return -1;
  586. }