C++ cs_log函数代码示例

static void do_report_emm_support(void)
{
	if(!config_enabled(WITH_CARDREADER))
	{
		cs_log("Binary without Cardreader Support! No EMM processing possible!");
	}
	else
	{
		report_emm_support(READER_NAGRA, "Nagra");
		report_emm_support(READER_IRDETO, "Irdeto");
		report_emm_support(READER_CONAX, "Conax");
		report_emm_support(READER_CRYPTOWORKS, "Cryptoworks");
		report_emm_support(READER_SECA, "Seca");
		report_emm_support(READER_VIACCESS, "Viaccess");
		report_emm_support(READER_VIDEOGUARD, "NDS Videoguard");
		report_emm_support(READER_DRE, "DRE Crypt");
		report_emm_support(READER_TONGFANG, "TONGFANG");
		report_emm_support(READER_BULCRYPT, "Bulcrypt");
		report_emm_support(READER_GRIFFIN, "Griffin");
		report_emm_support(READER_DGCRYPT, "DGCrypt");
	}
}

static int32_t radegast_recv(struct s_client *client, uchar *buf, int32_t l)
{
  int32_t n;
  if (!client->pfd) return(-1);
  if (client->typ == 'c') {  // server code
    if ((n=recv(client->pfd, buf, l, 0))>0)
      client->last=time((time_t *) 0);
  } else {  // client code
    if ((n=recv(client->pfd, buf, l, 0))>0) {
      cs_ddump_mask(D_CLIENT, buf, n, "radegast: received %d bytes from %s", n, remote_txt());
      client->last = time((time_t *) 0);

      if (buf[0] == 2) {  // dcw received
        if (buf[3] != 0x10) {  // dcw ok
          cs_log("radegast: no dcw");
          n = -1;
        }
      }
    }
  }
  return(n);
}

static void radegast_process_ecm(uchar *buf, int32_t l)
{
  int32_t i, n, sl;
  ECM_REQUEST *er;
  struct s_client *cl = cur_client();

  if (!(er=get_ecmtask()))
    return;
  for (i=0; i<l; i+=(sl+2))
  {
    sl=buf[i+1];
    switch(buf[i])
    {
      case  2:		// CAID (upper byte only, oldstyle)
        er->caid=buf[i+2]<<8;
        break;
      case 10:		// CAID
        er->caid=b2i(2, buf+i+2);
        break;
      case  3:		// ECM DATA
        //er->ecmlen = sl;
        er->ecmlen = (((buf[i+1+2] & 0x0F) << 8) | buf[i+2+2]) + 3;
        memcpy(er->ecm, buf+i+2, er->ecmlen);
        break;
      case  6:		// PROVID (ASCII)
        n=(sl>6) ? 3 : (sl>>1);
        er->prid=cs_atoi((char *) buf+i+2+sl-(n<<1), n, 0);
        break;
      case  7:		// KEYNR (ASCII), not needed
        break;
      case  8:		// ECM PROCESS PID ?? don't know, not needed
        break;
    }
  }
  if (l!=i)
    cs_log("WARNING: ECM-request corrupt");
  else
    get_cw(cl, er);
}

int csc_dodelchan(void *source, int cargc, char **cargv) {
  nick *sender=source;
  reguser *rup=getreguserfromnick(sender);
  chanindex *cip;
  regchan *rcp;
  char *reason;
  char buf[512];

  if (!rup)
    return CMD_ERROR;

  if (cargc<2) {
    chanservstdmessage(sender, QM_NOTENOUGHPARAMS, "delchan");
    return CMD_ERROR;
  }

  reason = cargv[1];
  if(!checkreason(sender, reason))
    return CMD_ERROR;

  if (!(cip=findchanindex(cargv[0])) || !(rcp=cip->exts[chanservext])) {
    chanservstdmessage(sender, QM_UNKNOWNCHAN, cargv[0]);
    return CMD_ERROR;
  }

  if (rcp->ID == lastchannelID) {
    chanservsendmessage(sender, "Sorry, can't delete last channel -- wait a while and try again.");
    return CMD_ERROR;
  }

  cs_log(sender,"DELCHAN %s (%s)",cip->name->content,reason);
  chanservwallmessage("%s (%s) just used DELCHAN on %s (reason: %s)", sender->nick, rup->username, cip->name->content, reason);
  snprintf(buf, sizeof(buf), "Channel deleted: %s", reason);
  cs_removechannel(rcp, buf);
  chanservstdmessage(sender, QM_DONE);

  return CMD_OK;
}

static dmx_t *find_demux(int32_t fd, int32_t dmx_dev_num)
{
	if(dmx_dev_num < 0 || dmx_dev_num >= MAX_COOL_DMX)
	{
		cs_log("Invalid demux %d", dmx_dev_num);
		return NULL;
	}

	int32_t i, idx;

	idx = dmx_dev_num;
	if(fd == 0)
	{
		for(i = 0; i < MAX_FILTER; i++)
		{
			if(!cdemuxes[idx][i].opened)
			{
				cdemuxes[idx][i].fd = COOLDEMUX_FD(dmx_dev_num, i);
				cs_debug_mask(D_DVBAPI, "opening new fd: %08x", cdemuxes[idx][i].fd);
				cdemuxes[idx][i].demux_index = dmx_dev_num;
				return &cdemuxes[idx][i];
			}
		}
		cs_debug_mask(D_DVBAPI, "ERROR: no free demux found");
		return NULL;
	}

	idx = COOLDEMUX_DMX_DEV(fd);
	for(i = 0; i < MAX_FILTER; i++)
	{
		if(cdemuxes[idx][i].fd == fd)
			{ return &cdemuxes[idx][i]; }
	}

	cs_debug_mask(D_DVBAPI, "ERROR: CANT FIND Demux %08x", fd);

	return NULL;
}

void gbox_write_peer_onl(void)
{
	FILE *fhandle = fopen(FILE_GBOX_PEER_ONL, "w");
	if(!fhandle)
	{
		cs_log("Couldn't open %s: %s\n", FILE_GBOX_PEER_ONL, strerror(errno));
		return;
	}
	struct s_client *cl;
	for(cl = first_client; cl; cl = cl->next)
	{
		if(cl->gbox && (cl->typ == 'p'))
		{
			struct gbox_peer *peer = cl->gbox;
			if (peer->online)
				{ fprintf(fhandle, "1 %s  %s %04X 2.%02X\n",cl->reader->device, cs_inet_ntoa(cl->ip),peer->gbox.id, peer->gbox.minor_version); }
			else
				{ fprintf(fhandle, "0 %s  %s %04X 0.00\n",cl->reader->device, cs_inet_ntoa(cl->ip),peer->gbox.id); }
		}
	}
	fclose(fhandle);
	return;
}	

int32_t constcw_analyse_file(uint16_t c_caid, uint32_t c_prid, uint16_t c_sid, uchar *dcw)
{
	//CAID:PROVIDER:SID:PMT:PID::XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX
	
	FILE *fp;
	char token[512];
	uint32_t caid, provid, sid, pmt, pid;
	int32_t cw[16];
	
	// FIXME
	c_prid = c_prid;
	
	fp=fopen(cur_client()->reader->device, "r");
	if (!fp) return (0);
	
	while (fgets(token, sizeof(token), fp)){
		if (token[0]=='#') continue;
		
		sscanf(token, "%4x:%6x:%4x:%4x:%4x::%2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x %2x", &caid, &provid, &sid, &pmt, &pid, 
			&cw[0], &cw[1], &cw[2],	&cw[3],	&cw[4], &cw[5], &cw[6], &cw[7], 
			&cw[8], &cw[9], &cw[10], &cw[11], &cw[12], &cw[13], &cw[14], &cw[15]);
		
		//cs_log("Line found: %s", token);
		if (c_caid == caid && c_sid == sid){
			fclose(fp);
			int8_t i;
			for(i = 0; i < 16; ++i)
				dcw[i] = (uchar) cw[i];
			cs_log("Entry found: %04X:%06X:%04X:%04X:%04X::%s", caid, provid, sid, pmt, pid, cs_hexdump(1, dcw, 16, token, sizeof(token)));
			return 1;
		}
	}
	
	fclose(fp);
	return 0;
}

void cs_disable_log(int8_t disabled)
{
	if(cfg.disablelog != disabled)
	{
		if(disabled && logStarted)
		{
			cs_log("Stopping log...");
			log_list_flush();
		}
		cfg.disablelog = disabled;
		if(disabled)
		{
			if(logStarted)
			{
				cs_sleepms(20);
				cs_close_log();
			}
		}
		else
		{
			cs_open_logfiles();
		}
	}
}

struct s_client *create_client(IN_ADDR_T ip)
{
	struct s_client *cl;
	if(!cs_malloc(&cl, sizeof(struct s_client)))
	{
		cs_log("max connections reached (out of memory) -> reject client %s", IP_ISSET(ip) ? cs_inet_ntoa(ip) : "with null address");
		return NULL;
	}
	
	//client part
	IP_ASSIGN(cl->ip, ip);
	cl->account = first_client->account;
	
	//master part
	SAFE_MUTEX_INIT(&cl->thread_lock, NULL);
	cl->login = cl->last = time(NULL);
	cl->tid = (uint32_t)rand();
	
	//Now add new client to the list:
	struct s_client *last;
	cs_writelock(__func__, &clientlist_lock);
	
	for(last = first_client; last && last->next; last = last->next)
		{ ; } //ends with cl on last client
		
	if (last)
		last->next = cl;
		
	int32_t bucket = (uintptr_t)cl / 16 % CS_CLIENT_HASHBUCKETS;
	cl->nexthashed = first_client_hashed[bucket];
	first_client_hashed[bucket] = cl;
	
	cs_writeunlock(__func__, &clientlist_lock);
	
	return cl;
}

/************************************************************************************************************************
 *       client functions
 *************************************************************************************************************************/
int pandora_client_init(struct s_client *cl) {
	static struct sockaddr_in loc_sa;
	int16_t p_proto;
	char ptxt[16];
	struct s_reader *rdr = cl->reader;
	uchar md5tmp[MD5_DIGEST_LENGTH];

	cl->pfd = 0;
	if (rdr->r_port <= 0) {
		cs_log("invalid port %d for server %s", rdr->r_port, rdr->device);
		return (1);
	}
	p_proto = IPPROTO_UDP;

	set_null_ip(&cl->ip);
	memset((char *) &loc_sa, 0, sizeof(loc_sa));
	loc_sa.sin_family = AF_INET;

	if (IP_ISSET(cfg.srvip))
		IP_ASSIGN(SIN_GET_ADDR(loc_sa), cfg.srvip);
	else
		loc_sa.sin_addr.s_addr = INADDR_ANY;
	loc_sa.sin_port = htons(rdr->l_port);

	if ((cl->udp_fd = socket(PF_INET, SOCK_DGRAM, p_proto)) < 0) {
		cs_log("Socket creation failed (errno=%d)", errno);
		return 1;
	}
	
	int32_t opt = 1;
	setsockopt(cl->udp_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt));
  
#ifdef SO_REUSEPORT
	setsockopt(cl->udp_fd, SOL_SOCKET, SO_REUSEPORT, (void *)&opt, sizeof(opt));
#endif

	set_socket_priority(cl->udp_fd, cfg.netprio);

	if (rdr->l_port > 0) {
		if (bind(cl->udp_fd, (struct sockaddr *) &loc_sa, sizeof(loc_sa)) < 0) {
			cs_log("bind failed (errno=%d)", errno);
			close(cl->udp_fd);
			return (1);
		}
		snprintf(ptxt, sizeof(ptxt), ", port=%d", rdr->l_port);
	} else
		ptxt[0] = '\0';

	memcpy(cl->pand_md5_key, MD5((uchar*)rdr->r_pwd, strlen(rdr->r_pwd), md5tmp), 16);
	cl->crypted = 1;

	//cl->grp = 0xFFFFFFFF;
	//rdr->caid[0] = rdr->ctab.caid[0];

	cl->pand_send_ecm = rdr->pand_send_ecm;
	memset((char *) &cl->udp_sa, 0, sizeof(cl->udp_sa));
#ifdef IPV6SUPPORT
	((struct sockaddr_in *)(&cl->udp_sa))->sin_family = AF_INET;
	((struct sockaddr_in *)(&cl->udp_sa))->sin_port = htons((u_short) rdr->r_port);
#else
	cl->udp_sa.sin_family = AF_INET;
	cl->udp_sa.sin_port = htons((u_short) rdr->r_port);
#endif

	cs_log("proxy %s:%d pandora %s (%s)", rdr->device, rdr->r_port, rdr->pand_send_ecm?"with ECM support":"", ptxt );

	cl->pfd = cl->udp_fd;
	//fcntl(cl->udp_fd, F_SETFL, fcntl(cl->udp_fd, F_GETFL, 0) | O_NONBLOCK); //!!!!!
	return (0);
}

static int32_t oscam_ser_check_ecm(ECM_REQUEST *er, uchar *buf, int32_t l)
{
  int32_t i;
  struct s_serial_client *serialdata = cur_client()->serialdata;

  if (l<16)
  {
    cs_log(incomplete, l);
    return(1);
  }

  switch(serialdata->connected)
  {
    case P_HSIC:
      er->ecmlen = l-12;
      er->caid = b2i(2, buf+1 );
      er->prid = b2i(3, buf+3 );
      er->pid  = b2i(2, buf+6 );
      er->srvid= b2i(2, buf+10);
      memcpy(er->ecm, buf+12, er->ecmlen);
      break;
    case P_SSSP:
      er->pid=b2i(2, buf+3);
      for (i=0; (i<8) && (serialdata->sssp_tab[i].pid!=er->pid); i++);
      if (i>=serialdata->sssp_num)
      {
        cs_debug_mask(D_CLIENT, "illegal request, unknown pid=%04X", er->pid);
        return(2);
      }
      er->ecmlen = l-5;
      er->srvid= serialdata->sssp_srvid;
      er->caid = serialdata->sssp_tab[i].caid;
      er->prid = serialdata->sssp_tab[i].prid;
      memcpy(er->ecm, buf+5, er->ecmlen);
      break;
    case P_BOMBA:
      er->ecmlen = l;
      memcpy(er->ecm, buf, er->ecmlen);
      break;
    case P_DSR95:
      buf[l]='\0';	// prepare for trim
      trim((char *)buf+13);	// strip spc, nl, cr ...
      er->ecmlen = strlen((char *)buf+13)>>1;
      er->prid=cs_atoi((char *)buf+3, 3, 0);	// ignore errors
      er->caid=cs_atoi((char *)buf+9, 2, 0);	// ignore errors
      if (cs_atob(er->ecm, (char *)buf+13, er->ecmlen)<0)
      {
        cs_log("illegal characters in ecm-request");
        return(1);
      }
      if( serialdata->dsr9500type==P_DSR_WITHSID )
      {
        er->ecmlen -= 2;
        er->srvid=cs_atoi((char *)buf+13+(er->ecmlen << 1), 2, 0);
      }
      break;
    case P_GS:
      er->ecmlen = ((buf[3]<<8)|buf[2]) - 6;
      er->srvid =  (buf[5]<<8)|buf[4]; // sid
      er->caid  =  (buf[7]<<8)|buf[6];
      er->prid  = 0;
      if (er->ecmlen > 256) er->ecmlen = 256;
      memcpy(er->ecm, buf+10, er->ecmlen);
      break;
    case P_ALPHA:
      l=oscam_ser_alpha_convert(buf, l);
      er->ecmlen= b2i(2, buf+1 )-2;
      er->caid  = b2i(2, buf+3 );
      if ((er->ecmlen!=l-5) || (er->ecmlen>257))
      {
        cs_log(incomplete, l);
        return(1);
      }
      memcpy(er->ecm, buf+5, er->ecmlen);
      break;
    case P_GBOX:
      er->srvid = b2i(2, buf+serialdata->gbox_lens.cat_len+3+3);
      er->ecmlen = serialdata->gbox_lens.ecm_len+3;
      memcpy(er->ecm, buf+serialdata->gbox_lens.cat_len+3+serialdata->gbox_lens.pmt_len+3, er->ecmlen);
      break;
  }
  return(0);
}

//.........这里部分代码省略.........
            serialdata->tpe.millitm+=50;
            if( !oscam_ser_selrec(buf, all-n, l, &n) )
              p=(-1);
          }
          // auto detect DSR9500 protocol
          if( client->typ == 'c' && p==P_DSR95 && serialdata->dsr9500type==P_DSR_AUTO )
          {
            serialdata->tpe.millitm+=20;
            if( oscam_ser_selrec(buf, 2, l, &n) )
            {
              if( cs_atoi((char *)buf+n-2, 1, 1)==0xFFFFFFFF )
              {
                switch( (buf[n-2]<<8)|buf[n-1] )
                {
                  case 0x0A0D : serialdata->dsr9500type=P_DSR_OPEN; break;
                  case 0x0D0A : serialdata->dsr9500type=P_DSR_PIONEER; break;
                  default     : serialdata->dsr9500type=P_DSR_UNKNOWN; break;
                }
              }else{
                if( oscam_ser_selrec(buf, 2, l, &n) )
                  if( cs_atoi((char *)buf+n-2, 1, 1)==0xFFFFFFFF )
                    serialdata->dsr9500type=P_DSR_UNKNOWN;
                  else
                    serialdata->dsr9500type=P_DSR_WITHSID;
                else {
                  serialdata->dsr9500type=P_DSR_UNKNOWN;
                  p=(-1);
                }
              }
            }
            else
              serialdata->dsr9500type=P_DSR_GNUSMAS;
            if( p )
              cs_log("detected dsr9500-%s type receiver",
                      dsrproto_txt[serialdata->dsr9500type]);
          }
          // gbox
          if( client->typ == 'c' && p==P_GBOX )
          {
            int32_t j;
            for( j=0; (j<3) && (p>0); j++)
              switch( j )
              {
                case 0: // PMT head
                  if( !oscam_ser_selrec(buf, 3, l, &n) )
                    p=(-1);
                  else if( !(buf[n-3]==0x02 && (buf[n-2]&0xf0)==0xb0) )
                    p=(-2);
                  break;
                case 1: // PMT + ECM header
                  serialdata->gbox_lens.pmt_len=((buf[n-2]&0xf)<<8)|buf[n-1];
                  if( !oscam_ser_selrec(buf, serialdata->gbox_lens.pmt_len+3, l, &n) )
                    p=(-1);
                  break;
                case 2: // ECM + ECM PID
                  serialdata->gbox_lens.ecm_len=((buf[n-2]&0xf)<<8)|buf[n-1];
                  if( !oscam_ser_selrec(buf, serialdata->gbox_lens.ecm_len+4, l, &n) )
                    p=(-1);
              }
          } // gbox
        }
        else if (r<0)	// read until specified char (-r)
        {
          while((buf[n-1]!=(-r)) && (p>0))
            if (!oscam_ser_selrec(buf, 1, l, &n))
              p=(-1);

int csu_dodomainmode(void *source, int cargc, char **cargv) {
  maildomain *mdp; 
  nick *sender=source;
  flag_t forceflags, currentflags;
  char buf1[60];
  int carg=2,limdone=0,actlimdone=0;
  unsigned int newlim=0;
  unsigned int newactlim=0;

  if (cargc<1) {
    chanservstdmessage(sender,QM_NOTENOUGHPARAMS,"domainmode");
    return CMD_ERROR;
  }

  if (checkdomain(cargv[0])) {
    chanservstdmessage(sender,QM_INVALIDDOMAIN,cargv[0]);
    return CMD_ERROR;
  }

  if(!(mdp=findorcreatemaildomain(cargv[0]))) {
    return CMD_ERROR;
  }

  if (cargc>1) {
    /* Save the current modes.. */
    strcpy(buf1,getdomainmode(mdp));

    /* Pick out the + flags: start from 0 */
    forceflags=0;
    setflags(&forceflags, MDFLAG_ALL, cargv[1], mdflags, REJECT_NONE);
    currentflags=mdp->flags;
    setflags(&currentflags, MDFLAG_ALL, cargv[1], mdflags, REJECT_NONE);

    if ((forceflags & MDFLAG_LIMIT) &&
        (!(forceflags & MDFLAG_ACTLIMIT) || strrchr(cargv[1],'l') < strrchr(cargv[1],'u'))) {
      if (cargc<=carg) {
        chanservstdmessage(sender,QM_NOTENOUGHPARAMS,"domainmode");
        return CMD_ERROR;
      }
      newlim=strtol(cargv[carg++],NULL,10);
      limdone=1;
    }

    if ((forceflags & MDFLAG_LIMIT) && !limdone) {
      if (cargc<=carg) {
        chanservstdmessage(sender,QM_NOTENOUGHPARAMS,"domainmode");
        return CMD_ERROR;
      }
      newlim=strtol(cargv[carg++],NULL,10);
      limdone=1;
    }

    if ((forceflags & MDFLAG_ACTLIMIT) && !actlimdone) {
      if (cargc<=carg) {
        chanservstdmessage(sender,QM_NOTENOUGHPARAMS,"chanmode");
        return CMD_ERROR;
      }
      newactlim=strtol(cargv[carg++],NULL,10);
      actlimdone=1;
    }

    /* It parsed OK, so update the structure.. */
    mdp->flags=currentflags;
    if(actlimdone)
      mdp->actlimit=newactlim; 
    if(!(currentflags & MDFLAG_ACTLIMIT))
      mdp->actlimit=0;
    if(limdone)
      mdp->limit=newlim;
    if(!(currentflags & MDFLAG_LIMIT))
      mdp->limit=0;
    if(mdp->ID) {
      if(mdp->flags) {
        csdb_updatemaildomain(mdp);
      } else {
        csdb_deletemaildomain(mdp);
      }
    } else {
      mdp->ID=++lastdomainID;
      csdb_createmaildomain(mdp);
    }

    chanservstdmessage(sender, QM_DONE);
    cs_log(sender,"DOMAINMODE %s %s (%s -> %s)",mdp->name->content,cargv[1],buf1,getdomainmode(mdp));
  }
  chanservstdmessage(sender,QM_CURDOMAINMODES,mdp->name->content,getdomainmode(mdp));
 
  return CMD_OK;
}

static void cs_master_alarm(void)
{
  cs_log("PANIC: master deadlock!");
  fprintf(stderr, "PANIC: master deadlock!");
  fflush(stderr);
}

static void process_clients(void) {
	int32_t i, k, j, rc, pfdcount = 0;
	struct s_client *cl;
	struct s_reader *rdr;
	struct pollfd *pfd;
	struct s_client **cl_list;
	uint32_t cl_size = 0;

	char buf[10];

	if (pipe(thread_pipe) == -1) {
		printf("cannot create pipe, errno=%d\n", errno);
		exit(1);
	}

	cl_size = chk_resize_cllist(&pfd, &cl_list, 0, 100);

	pfd[pfdcount].fd = thread_pipe[0];
	pfd[pfdcount].events = POLLIN | POLLPRI | POLLHUP;
	cl_list[pfdcount] = NULL;

	while (!exit_oscam) {
		pfdcount = 1;

		//connected tcp clients
		for (cl=first_client->next; cl; cl=cl->next) {
			if (cl->init_done && !cl->kill && cl->pfd && cl->typ=='c' && !cl->is_udp) {
				if (cl->pfd && !cl->thread_active) {
					cl_size = chk_resize_cllist(&pfd, &cl_list, cl_size, pfdcount);
					cl_list[pfdcount] = cl;
					pfd[pfdcount].fd = cl->pfd;
					pfd[pfdcount++].events = POLLIN | POLLPRI | POLLHUP;
				}
			}
			//reader:
			//TCP:
			//	- TCP socket must be connected
			//	- no active init thread
			//UDP:
			//	- connection status ignored
			//	- no active init thread
			rdr = cl->reader;
			if (rdr && cl->typ=='p' && cl->init_done) {
				if (cl->pfd && !cl->thread_active && ((rdr->tcp_connected && rdr->ph.type==MOD_CONN_TCP)||(rdr->ph.type==MOD_CONN_UDP))) {
					cl_size = chk_resize_cllist(&pfd, &cl_list, cl_size, pfdcount);
					cl_list[pfdcount] = cl;
					pfd[pfdcount].fd = cl->pfd;
					pfd[pfdcount++].events = POLLIN | POLLPRI | POLLHUP;
				}
			}
		}

		//server (new tcp connections or udp messages)
		for (k = 0; k < CS_MAX_MOD; k++) {
			struct s_module *module = &modules[k];
			if ((module->type & MOD_CONN_NET)) {
				for (j = 0; j < module->ptab.nports; j++) {
					if (module->ptab.ports[j].fd) {
						cl_size = chk_resize_cllist(&pfd, &cl_list, cl_size, pfdcount);
						cl_list[pfdcount] = NULL;
						pfd[pfdcount].fd = module->ptab.ports[j].fd;
						pfd[pfdcount++].events = POLLIN | POLLPRI | POLLHUP;
					}
				}
			}
		}

		if (pfdcount >= 1024)
			cs_log("WARNING: too many users!");

		rc = poll(pfd, pfdcount, 5000);

		if (rc<1)
			continue;

		for (i=0; i<pfdcount; i++) {
			//clients
			cl = cl_list[i];
			if (cl && !is_valid_client(cl))
				continue;

			if (pfd[i].fd == thread_pipe[0] && (pfd[i].revents & (POLLIN | POLLPRI))) {
				// a thread ended and cl->pfd should be added to pollfd list again (thread_active==0)
				if(read(thread_pipe[0], buf, sizeof(buf)) == -1){
					cs_debug_mask(D_TRACE, "Reading from pipe failed (errno=%d %s)", errno, strerror(errno));
				}
				continue;
			}

			//clients
			// message on an open tcp connection
			if (cl && cl->init_done && cl->pfd && (cl->typ == 'c' || cl->typ == 'm')) {
				if (pfd[i].fd == cl->pfd && (pfd[i].revents & (POLLHUP | POLLNVAL))) {
					//client disconnects
					kill_thread(cl);
					continue;
				}
				if (pfd[i].fd == cl->pfd && (pfd[i].revents & (POLLIN | POLLPRI))) {
					add_job(cl, ACTION_CLIENT_TCP, NULL, 0);
				}
//.........这里部分代码省略.........