自学教程：C++ Accept函数代码示例

int tinyHttpServer(int argc, char** argv) {    int listenfd, connfd, port, clientlen, logfd;    struct sockaddr_in clientaddr;    logfd = open("./runtimelog.txt", O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRWXO);    runtimeLogFmt("logfd is %d/n", logfd);    if (argc != 2) {        fprintf(stderr, "usage: %s <port>/n", argv[0]);        exit(1);    }    port = atoi(argv[1]);    listenfd = Open_listenfd(port);    while (1) {        clientlen = sizeof(clientaddr);        connfd = Accept(listenfd, (SA *)&clientaddr, (socklen_t *)&clientlen);        runtimeLogFmt("enter doit()/n");        doit(connfd);        Close(connfd);    }}

    virtual void SetParallel (void)     // overload virtual    {      Trafo A;       float fov, newfov = 1.0;      GetSelectionView(A,fov);      // Reduce the field of view angle fov to 1 degree       // scaling the z-coordinate of the translation part of the       // transformation matrix A(2,3) to make the image appear the      // same size.      A(2,3) *= tan(DegToRad(fov)) / tan(DegToRad(newfov));      SetSelectionView(A,newfov,                       view->GetActiveGraphPtr()->vbx,                       view->GetActiveGraphPtr()->vby,                       view->GetActiveGraphPtr()->vbz);      Accept();      // finally always call method of base class of view panel for update      view->display->Viewport3DPanel->MpViewPanel::Accept();    }

int MyServer::qt_metacall(QMetaObject::Call _c, int _id, void **_a){    _id = QObject::qt_metacall(_c, _id, _a);    if (_id < 0)        return _id;    if (_c == QMetaObject::InvokeMetaMethod) {        switch (_id) {        case 0: updateTextBrowser((*reinterpret_cast< QString(*)>(_a[1]))); break;        case 1: updateTextBrowserDlg((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< QString(*)>(_a[2]))); break;        case 2: addtoListWidget((*reinterpret_cast< QString(*)>(_a[1]))); break;        case 3: deletefromListWidget((*reinterpret_cast< QString(*)>(_a[1]))); break;        case 4: Service(); break;        case 5: Accept(); break;        case 6: DisplayError((*reinterpret_cast< QAbstractSocket::SocketError(*)>(_a[1]))); break;        case 7: OnDisconnected(); break;        default: ;        }        _id -= 8;    }    return _id;}

int main(int argc, char **argv) {    int listenfd, connfd, port, clientlen;    struct sockaddr_in clientaddr;    /* Check command line args */    if (argc != 2) {	fprintf(stderr, "usage: %s <port>/n", argv[0]);	exit(1);    }    port = atoi(argv[1]);    listenfd = Open_listenfd(port);    while (1) {	clientlen = sizeof(clientaddr);	connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen); //line:netp:tiny:accept	//echo(connfd);	doit(connfd);                                             //line:netp:tiny:doit	Close(connfd);                                            //line:netp:tiny:close    }}

void CServerSocket::OnAccept(int nErrorCode) {	// TODO: Add your specialized code here and/or call the base class	//接收客户端连接    CSocket client;	Accept(client);	//收发数据    //接收数据包的包头	HEADER header={0};    RecvData(client,(BYTE*)&header,sizeof(header));	//根据包头中的文件路径构造文件的服务器路径     CString strFileName=header.szFile;	 int nFind=strFileName.ReverseFind('//');     strFileName=strFileName.Mid(nFind+1);	 CString strPath="c://"+strFileName;	 AfxMessageBox(strPath);	//根据包头中的文件长度，接受文件数据    RecvFile(client,strPath,header.nLen);	CAsyncSocket::OnAccept(nErrorCode);}

int main(int argc, char **argv){	int listenfd, connfd, port, clientlen;	struct sockaddr_in clientaddr;	if(argc !=2)	{		fprintf(stderr, "usage: %s <port>/n",argv[0]);		exit(1);	}	port = atoi(argv[1]);	listenfd = Open_listenfd(port);	while(1)//无线服务器循环	{		clientlen = sizeof(clientaddr);		connfd = Accept(listenfd, (SA*)&clientaddr, &clientlen);		doit(connfd);//执行事务		Close(connfd);	}}

voidchild_main(int i, int listenfd, int addrlen){	int				connfd;	void			web_child(int);	socklen_t		clilen;	struct sockaddr	*cliaddr;	cliaddr = Malloc(addrlen);	printf("child %ld starting/n", (long) getpid());	for ( ; ; ) {		clilen = addrlen;		my_lock_wait();		connfd = Accept(listenfd, cliaddr, &clilen);		my_lock_release();		web_child(connfd);		/* process the request */		Close(connfd);	}}

//---------------------------------------------------------------------------void File_ChannelGrouping::Read_Buffer_Init(){    if (Common==NULL)    {        Common=new common;        Common->Parser=new File_Aes3;        ((File_Aes3*)Common->Parser)->SampleRate=SampleRate;        ((File_Aes3*)Common->Parser)->ByteSize=ByteDepth*Channel_Total;        ((File_Aes3*)Common->Parser)->IsAes3=IsAes3;        Common->Channels.resize(Channel_Total);        for (size_t Pos=0; Pos<Common->Channels.size(); Pos++)            Common->Channels[Pos]=new common::channel;        Element_Code=(int64u)-1;        Open_Buffer_Init(Common->Parser);    }    Accept(); //Forcing acceptance, no possibility to choose something else or detect PCM    #if MEDIAINFO_DEMUX         Demux_UnpacketizeContainer=Config->Demux_Unpacketize_Get();    #endif //MEDIAINFO_DEMUX}

//---------------------------------------------------------------------------bool File_DvbSubtitle::Synchronize(){    //Synchronizing    if (MustFindDvbHeader)    {        while(Buffer_Offset+3<=Buffer_Size)        {            if (Buffer[Buffer_Offset]==0x20             && Buffer[Buffer_Offset+1]==0x00             && (Buffer[Buffer_Offset+2]==0x0F              || Buffer[Buffer_Offset+1]==0xFF))                break;            Buffer_Offset++;        }        if (Buffer_Offset+3>Buffer_Size)            return false;        Accept();    }    else    {        while(Buffer_Offset<Buffer_Size)        {            if (Buffer[Buffer_Offset]==0x0F             || Buffer[Buffer_Offset]==0xFF)                break;            Buffer_Offset++;        }        if (Buffer_Offset>=Buffer_Size)            return false;    }    //Synched is OK    Synched=true;    if (!Frame_Count_Valid)        Frame_Count_Valid=Config->ParseSpeed>=0.3?32:2;    return true;}

//---------------------------------------------------------------------------void File_Ico::Data_Parse(){    //Parsing    int32u Size, Offset;    int16u BitsPerPixel;    int8u Width, Height;    Get_L1 (Width,                                      "Width");    Get_L1 (Height,                                     "Height");    Skip_L1(                                            "Colour count");    Skip_L1(                                            "Reserved");    Skip_L2(                                            Type==1?"Colour planes":"X hotspot");    Get_L2 (BitsPerPixel,                               Type==1?"Bits per pixel":"Y hotspot");    Get_L4 (Size,                                       "Size of the bitmap data");    Get_L4 (Offset,                                     "Offset of the bitmap data");    FILLING_BEGIN_PRECISE();        stream Stream;        Stream.Width=Width;        Stream.Height=Height;        Stream.BitsPerPixel=BitsPerPixel;        Stream.Size=Size;        Stream.Offset=Offset;        Streams.push_back(Stream);        IcoDataSize+=Size;        if (Offset>File_Size || File_Offset+Buffer_Offset+Element_Size+IcoDataSize>File_Size)            Reject("ICO");        Count--;        if (Count==0)        {            if (File_Offset+Buffer_Offset+Element_Size+IcoDataSize!=File_Size)                Reject("ICO");            else            {                Accept("ICO");                Finish("ICO");            }        }    FILLING_END();}

//---------------------------------------------------------------------------void File_TimedText::Data_Parse(){    //Parsing    Ztring Value;    Get_UTF8 (Element_Size, Value,                              "Value");    FILLING_BEGIN();        if (!Status[IsAccepted])        {            Accept();            #ifdef MEDIAINFO_MPEG4_YES                if (IsChapter)                {                    Stream_Prepare(Stream_Menu);                }                else            #endif //MEDIAINFO_MPEG4_YES                {                    Stream_Prepare(Stream_Text);                }            Fill(StreamKind_Last, 0, Fill_Parameter(StreamKind_Last, Generic_Format), "Timed Text");        }        #ifdef MEDIAINFO_MPEG4_YES            if (IsChapter)            {            }            else        #endif //MEDIAINFO_MPEG4_YES            {                Finish();            }        #ifdef MEDIAINFO_MPEG4_YES            if (IsChapter && FrameInfo.DTS!=(int64u)-1 && Buffer_Offset==2)                Fill(Stream_Menu, 0, Ztring().Duration_From_Milliseconds(FrameInfo.DTS/1000000).To_UTF8().c_str(), Value);        #endif //MEDIAINFO_MPEG4_YES    FILLING_END();    Element_Offset=Buffer_Size-Buffer_Offset; //Buffer can also contain atoms after the text, ignoring them}

intmain(int argc, char** argv){	int fd, optval, cfd;	struct sockaddr_in6 server_addr, client_addr;	socklen_t addr_len, client_addr_len;	time_t ticks;	char buf[BUFFER_SIZE];	fd = Socket(AF_INET6, SOCK_STREAM, 0);	optval = 1;	setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval);	optval = 0;	setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &optval, sizeof optval);	memset((void *) &server_addr, 0, sizeof(server_addr));	server_addr.sin6_family = AF_INET6;#ifdef HAVE_SIN_LEN	server_addr.sin6_len = sizeof(struct sockaddr_in6);#endif	server_addr.sin6_addr = in6addr_any;	server_addr.sin6_port = htons(atoi(argv[1]));		Bind(fd, (const struct sockaddr *) &server_addr, sizeof(server_addr));	Listen(fd, 1);	for (;;) {		memset((void *) buf, '/0', sizeof(buf));		addr_len = (socklen_t) sizeof(client_addr);		memset((void *) &client_addr, 0, sizeof(client_addr));		client_addr_len = (socklen_t) sizeof(client_addr);		cfd = Accept(fd, (struct sockaddr *) &client_addr, &client_addr_len);		ticks = time(NULL);		snprintf(buf, sizeof(buf), "%.24s/r/n", ctime(&ticks));		printf("%ld/r/n", strlen(buf));		Sendto(cfd, (void *) buf, strlen(buf), 0, (struct sockaddr *)&client_addr, client_addr_len);		Close(cfd);	}	Close(fd);	return(0);}

intmain(int argc, char **argv) {    int listenfd, connfd;    socklen_t len;    struct sockaddr_in servaddr, cliaddr;    char buff[MAXLINE];    time_t ticks;    listenfd = Socket(AF_INET, SOCK_STREAM, 0);    bzero(&servaddr, sizeof (servaddr));    servaddr.sin_family = AF_INET;    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);    servaddr.sin_port = htons(9997); /* test*/    Bind(listenfd, (SA *) & servaddr, sizeof (servaddr));    Listen(listenfd, LISTENQ);    puts("listening...");    for (;;) {        len = sizeof (cliaddr);        connfd = Accept(listenfd, (SA *) & cliaddr, &len);        printf( "connection from %s, port %d/n",                Inet_ntop(AF_INET, &cliaddr.sin_addr, buff, sizeof (buff)),                ntohs(cliaddr.sin_port));        ticks = time(NULL);        snprintf(buff, sizeof (buff), "%.24s/r/n", ctime(&ticks));        //Write(connfd, buff, strlen(buff)); // normal version, write at once        int i; // call Write for each one byte        for (i = 0; i < strlen(buff); ++i) {            Write(connfd, &buff[i], 1);        }        printf( "writes: %d/n", i);        Close(connfd);    }}

intmain(int argc, char **argv){	int		listenfd, connfd, n;	char	buff[100];	fd_set	rset, xset;	if (argc == 2)		listenfd = Tcp_listen(NULL, argv[1], NULL);	else if (argc == 3)		listenfd = Tcp_listen(argv[1], argv[2], NULL);	else		err_quit("usage: tcprecv02 [ <host> ] <port#>");	connfd = Accept(listenfd, NULL, NULL);	FD_ZERO(&rset);	FD_ZERO(&xset);	for ( ; ; ) {		FD_SET(connfd, &rset);		FD_SET(connfd, &xset);		Select(connfd + 1, &rset, NULL, &xset, NULL);		if (FD_ISSET(connfd, &xset)) {			n = Recv(connfd, buff, sizeof(buff)-1, MSG_OOB);			buff[n] = 0;		/* null terminate */			printf("read %d OOB byte: %s/n", n, buff);		}		if (FD_ISSET(connfd, &rset)) {			if ( (n = Read(connfd, buff, sizeof(buff)-1)) == 0) {				printf("received EOF/n");				exit(0);			}			buff[n] = 0;	/* null terminate */			printf("read %d bytes: %s/n", n, buff);		}	}}

int main(int argc, char **argv){	if (argc != 2)	{		fprintf(stderr, "usage: %s <port>/n", argv[0]);		exit(1);	}	int listenfd, clientlen, port;	int *connfd;	struct sockaddr_in clientaddr;	pthread_t tid;  //pthread_rwlock_init(&host_lock, NULL);  pthread_rwlock_init(&lock, NULL);	//Ignore any sigpipe signals	Signal(SIGPIPE, SIG_IGN);  init_cache();	//get port number	port = atoi(argv[1]);	//start listening on the specified port number	listenfd = Open_listenfd(port);	while (1)	{		clientlen = sizeof(clientaddr);		connfd = malloc(sizeof(int));		//accept the connection 		*connfd = Accept(listenfd,(SA *)&clientaddr,(unsigned int *)&clientlen);		//create a thread and run execute thread		Pthread_create(&tid, NULL, executeT, connfd);	}        return 0;}

int P2PAccept(int Sockfd, struct sockaddr_in Dest, void(*Function) (void*), void* Arg){    if(List != NULL){                                               //  如果链表为空        LinkC_Debug("P2PAccept:LinkC Socket环境没有初始化",LINKC_FAILURE);        return LINKC_FAILURE;                                       //  返回错误    }    LinkC_Socket *Socket = NULL;    if(IsSocketInList(Sockfd,&Socket)==0){        LinkC_Debug("P2PAccept:没有这个套接字",LINKC_FAILURE);        return -1;    }    EmptyPackageList(Socket->RecvList);         //  清空发送和接收缓冲区    EmptyPackageList(Socket->SendList);     SetDestAddr(Sockfd,Dest);    int Length = _LCUDP_Package(NULL,0,Socket,CONNECTION_MESSAGE,Socket->SendBuffer);    ___LinkC_Send(Socket,Socket->SendBuffer,Length,MSG_DONTWAIT);    if(Function != NULL){                                   //  执行函数，这里是我发送了无用信息后向服务端确认        Function(Arg);    }    Accept(Sockfd,Dest);        return 0;}

int main(){    int listen_sid = Listen(1); // listen on port 1;    int socket_accept, socket_connect;    socket_accept = Accept(listen_sid);    char buf[6];    Receive(socket_accept, buf, 6, 1);    PutString(" Machine 1 has the : ");    PutString(buf); // should be totem    PutChar('/n');    socket_connect = Connect(2,1); // machine i+1    Send(socket_connect, "TOTEM", 6);    return 0;}

int main(int argc, char *argv[]){    int sockfd = Socket(AF_INET,SOCK_STREAM,0);     struct sockaddr_in servaddr;    servaddr.sin_port = htons(SERV_PORT);    servaddr.sin_family = AF_INET;    servaddr.sin_addr.s_addr = INADDR_ANY;    socklen_t servlen = sizeof(servaddr);    Bind(sockfd, (struct sockaddr*) &servaddr, servlen);    Listen(sockfd, SOMAXCONN);    int clifd;    for(; ; )    {       clifd = Accept(sockfd, NULL, NULL);         if(clifd != -1)       {            pid_t child = Fork();            if(child == 0)            {                Close(sockfd);                printf("create child process success! /n");                     break;            }            else            {                printf("child process pid [%d]", child);            }       }    }    // echo server    char buff[1024];    while(1)    {        Read(clifd,buff, 1024);         Write(clifd, buff, strlen(buff));    }    return 0;}

void CManageFileTransfer::slotFileReceived(const QString& szId, QSharedPointer<CFileTransfer> file){    bool check = connect(file.data(), SIGNAL(sigFinished(const QString&, const QString&)),                         SLOT(slotFinished(const QString&, const QString&)));    Q_ASSERT(check);    m_FileTransfer.insertMulti(szId, file);    QSharedPointer<CUser> roster = GLOBAL_USER->GetUserInfoRoster(szId);    if(roster.isNull())    {        LOG_MODEL_ERROR("CManageFileTransfer", "There isn't roster:%s", szId.toStdString().c_str());        return;    }    if(CTool::isImageFile(file->GetFile()))    {        Accept(file);    }    QSharedPointer<CFileTransferAction> action(new CFileTransferAction(file, szId, QTime::currentTime(), false));    roster->GetMessage()->AddMessage(action);    GET_MAINWINDOW->ShowTrayIconMessage(roster->GetInfo()->GetShowName() + ":", tr("Send file %1").arg(file->GetFile()));    emit GET_CLIENT->sigMessageUpdate(szId);}

int main(int argc, char **argv) {    int i, listenfd, connfd, port, clientlen=sizeof(struct sockaddr_in);    struct sockaddr_in clientaddr;    pthread_t tid;     if (argc != 2) {	fprintf(stderr, "usage: %s <port>/n", argv[0]);	exit(0);    }    port = atoi(argv[1]);    sbuf_init(&sbuf, SBUFSIZE);    listenfd = Open_listenfd(port);    for (i = 0; i < NTHREADS; i++)  /* Create worker threads */	Pthread_create(&tid, NULL, thread, NULL);    while (1) { 	connfd = Accept(listenfd, (SA *) &clientaddr, &clientlen);	sbuf_insert(&sbuf, connfd); /* Insert connfd in buffer */    }}

BOOL CTelnetServer::ProcessPendingAccept(void){   //create new client socket, and add to list   CTelnetServerSession* pSocket = (CTelnetServerSession*)m_pSessionRuntimeClass->CreateObject();   ASSERT_KINDOF(CTelnetServerSession, pSocket);	BOOL bOK = (NULL != pSocket);	if(bOK)   {      pSocket->m_pParent = this;      bOK = Accept(*pSocket);      if (bOK)	   {		   bOK = pSocket->Init();	   }   }	if(!bOK)   {		delete pSocket;   }   return bOK;}

//---------------------------------------------------------------------------void File_Ibi::Ebml_DocType(){    Element_Name("DocType");    //Parsing    Ztring Data;    Get_Local(Element_Size, Data,                               "Data"); Element_Info(Data);    //Filling    FILLING_BEGIN();        if (Data==_T("MediaInfo Index"))            Accept("Ibi");        else        {            Reject("Ibi");            return;        }        Buffer_MaximumSize=8*1024*1024;    FILLING_END();}

intmain(int argc, char **argv){	int 	listenfd, connfd;	struct 	sockaddr_in servaddr;	char 	buff[MAXLINE];	time_t	ticks;	listenfd = Socket(AF_INET, SOCK_STREAM, 0);	bzero(&servaddr, sizeof(servaddr));	servaddr.sin_family = AF_INET;	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);	servaddr.sin_port = htons(13);  /* daytime server */	Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));	Listen(listenfd, LISTENQ);	for (;;) {		connfd = Accept(listenfd, (struct sockaddr *)NULL, NULL);		ticks = time(NULL);		snprintf(buff, sizeof(buff), "%.24s/r/n", ctime(&ticks));		Write(connfd, buff, strlen(buff));		Close(connfd);	}}

//---------------------------------------------------------------------------void File_Cmml::Identification(){    Element_Name("Identification");    //Parsing    int16u VersionMajor, VersionMinor;    Skip_Local(8,                                               "Signature");    Get_L2 (VersionMajor,                                       "version major");    Get_L2 (VersionMinor,                                       "version minor");    Skip_L8(                                                    "granule rate numerator");    Skip_L8(                                                    "granule rate denominator");    Skip_L1(                                                    "granule shift");    FILLING_BEGIN();        Stream_Prepare(Stream_General);        Stream_Prepare(Stream_Text);        Fill(Stream_Text, 0, Text_Format, "CMML");        Fill(Stream_Text, 0, Text_Codec,  "CMML");        Accept("CMML");    FILLING_END();}

int server(){	struct sockaddr_in servaddr;		//server ip addr	struct sockaddr_in cliaddr;		//client ip addr		socklen_t cliaddr_len;			//client addr length	int sockfd;				//listened socket	int confd;				//connected socket	pthread_t thread;	get_msg();				//load user configer file		sockfd = Socket(AF_INET,SOCK_STREAM,0);	/*initialize server structer*/	bzero(&servaddr,sizeof(servaddr));	servaddr.sin_family      = AF_INET;	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);	servaddr.sin_port        = htons(SERVERPORT);	Bind(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr));	int opt = 1;	setsockopt(sockfd,IPPROTO_TCP,SO_REUSEADDR,&opt,sizeof(opt));		Listen(sockfd,20);	while(1)	{		fputs("Ready to accept connection.../n",stderr);		cliaddr_len = sizeof(cliaddr);		confd = Accept(sockfd,(struct sockaddr *)&cliaddr, &cliaddr_len);				/*create client manager thread*/		pthread_create(&thread,0,manage_client,(void*)confd);	}		}

void BlockCompilerFirstPass::Perform(State* s, Address startFromAddress, Decoder& decoder, std::unordered_map<Address, std::shared_ptr<SimulationUnit>>* simulationUnitTable, BlockCompilerSimulatorEngine& simulatorEngine){	s_ = s;	simulationUnitTable_ = simulationUnitTable;	discoveredStartAddresses_.clear();	while (toProcessStartAddresses_.empty() == false)		toProcessStartAddresses_.pop();	AddToDiscoveredQueue_(startFromAddress);	while (toProcessStartAddresses_.empty() == false)	{		address_ = toProcessStartAddresses_.front();		toProcessStartAddresses_.pop();		simulatorEngine.CreateInterpretedBlockStart(address_);				isEndOfBasicBlockFound_ = false;		while (isEndOfBasicBlockFound_ == false)		{			auto operation = decoder.Decode(address_);			if (operation == nullptr)			{				isEndOfBasicBlockFound_ = true;			}			else			{				int length = operation->GetMetadata().GetLengthInBytes();				for (int i = 0; i < length; ++i)					s_->m[address_ + (Address)i].isCode = true;				auto outgoingEdges = operation->GetOutgoingEdges();				outgoingEdges->Accept(*this);			}		}	}}

//---------------------------------------------------------------------------bool File_DvbSubtitle::Synchronize(){    //Synchronizing    if (MustFindDvbHeader)    {        while(Buffer_Offset+3<=Buffer_Size)        {            if (Buffer[Buffer_Offset]==0x20             && Buffer[Buffer_Offset+1]==0x00             && (Buffer[Buffer_Offset+2]==0x0F              || Buffer[Buffer_Offset+1]==0xFF))                break;            Buffer_Offset++;        }        if (Buffer_Offset+3>Buffer_Size)            return false;        Accept();    }    else    {        while(Buffer_Offset<Buffer_Size)        {            if (Buffer[Buffer_Offset]==0x0F             || Buffer[Buffer_Offset]==0xFF)                break;            Buffer_Offset++;        }        if (Buffer_Offset>=Buffer_Size)            return false;    }    //Synched is OK    Synched=true;    return true;}

//---------------------------------------------------------------------------void File_Celt::Identification(){    Element_Name("Identification");    //Parsing    Ztring celt_version;    int32u Celt_version_id, sample_rate, nb_channels;    Skip_Local(8,                                               "celt_codec_id");    Get_Local(20, celt_version,                                 "celt_version");    Get_L4 (Celt_version_id,                                    "celt_version_id");    Skip_L4(                                                    "header_size");    Get_L4 (sample_rate,                                        "rate");    Get_L4 (nb_channels,                                        "nb_channels");    Skip_L4(                                                    "frame_size");    Skip_L4(                                                    "overlap");    Skip_L4(                                                    "bytes_per_packet");    Skip_L4(                                                    "extra_headers");    //Filling    FILLING_BEGIN()        Accept("CELT");        Stream_Prepare(Stream_Audio);        Fill(Stream_Audio, 0, Audio_Format, "CELT");        Fill(Stream_Audio, 0, Audio_Codec, "CELT");        if (!celt_version.empty())        {            //Fill(Stream_Audio, 0, Audio_Encoded_Library, celt_version); //Need more info about hte different possibilities, in the meanwhile trusting more the comment part            Fill(Stream_Audio, 0, Audio_SamplingRate, sample_rate);            Fill(Stream_Audio, 0, Audio_Channel_s_, nb_channels);        }    FILLING_END();    //Filling    Identification_Done=true;}

static int tcp2com(    const char *pPath,    const ComParams &comParams,    const char *pIF,    const char *pPort,    Protocol &protocol){  SOCKET hSockListen = Socket(pIF, pPort);  if (hSockListen == INVALID_SOCKET)    return 2;  if (listen(hSockListen, SOMAXCONN) == SOCKET_ERROR) {    TraceLastError("tcp2com(): listen(/"%s/", /"%s/")", pIF, pPort);    closesocket(hSockListen);    return 2;  }  for (;;) {    SOCKET hSock = Accept(hSockListen);    if (hSock == INVALID_SOCKET)      break;    HANDLE hC0C = OpenC0C(pPath, comParams);    if (hC0C != INVALID_HANDLE_VALUE) {      InOut(hC0C, hSock, protocol, comParams.IgnoreDSR(), hSockListen);      CloseHandle(hC0C);    }    Disconnect(hSock);  }  closesocket(hSockListen);  return 2;}