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

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

DVD

开发平台：

Unix_Linux

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