URL extractor with PCRE

/* test by Cooler_
 gcc -o code code.c -lpcre -lcurl

 ./spiderpcre www.telona.org
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pcre.h>
#include <curl/curl.h>
#include <curl/easy.h>

char *parse(char *str, int start, int end);
void *xmalloc(size_t size);
static size_t WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data);

void help()
{
 puts(
  "Simple Spider to parse URLs v0.01\n"
  "./code url\n"
  " ------------------------------------\n"
  " by Cooler_ , BugSec Team , contact: c00f3r[at]gmail[dot]com\n"
 );
}

struct MemoryStruct {
 char *memory;
 size_t size;
};

int main(int argc, char ** argv)
{
 struct MemoryStruct chunk;

// curl vars
 CURL *curl_handle;
 curl_global_init(CURL_GLOBAL_ALL);

 char *url=NULL,*target=NULL,*URL=NULL;
 const char *errText;
 int errOffset=0,cmd=0,offset=0,count=0;
 int array[6];
 pcre *regex;

 if(argc<2)
 {
  help();
  return 0;
 }

 if(strlen(argv[1])<256)
  target=argv[1];
 else
 {
  puts("erro no primeiro argumento");
  return 0;
 }


// regex pcre
 regex = pcre_compile("href=[\\S>]+", 0, &errText, &errOffset, NULL);

  if(!regex)
  {
   fprintf(stderr, "Erro: %s (%d)\n", errText, errOffset);
   return 0;
  }
  else
  {
   fprintf(stdout,"\npegando urls de %s\n",target);

   puts("------------------\n");
   chunk.memory=NULL;
   chunk.size=0;

   curl_handle=curl_easy_init();
   curl_easy_setopt(curl_handle, CURLOPT_URL, target);
   curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION,WriteMemoryCallback);
   curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA,(void *)&chunk);
   curl_easy_setopt(curl_handle, CURLOPT_USERAGENT,"Mozilla/5.0 (Windows; U; Windows NT 5.1; pl; rv:1.9.0.17) Gecko/2009122116 Firefox/3.0.17 ");
   curl_easy_perform(curl_handle);
   curl_easy_cleanup(curl_handle);

   if(chunk.memory)
   {
    while(1)
    {
     cmd=pcre_exec(regex, NULL, chunk.memory, strlen(chunk.memory), offset, 0, array, 6);
      if(cmd <= 0)
       break;
     url=parse(chunk.memory, array[0], array[1]);

     url+=6;
     while(*url!='"')
     {
      fprintf(stdout,"%c",*url);
      url++;
     }
     puts("");
     offset = array[1]+1;

    }

    pcre_free(regex);
   }
  }

 if(chunk.size)
  free(chunk.memory);

 curl_global_cleanup();

 return 0;
}


char *parse(char *str, int start, int end)
{
 char *word=(char *)xmalloc(sizeof(char)*2048);
 int x=0;

 while(start != end)
 {
  word[x]=str[start];
  start++,x++;
 }

 free(word);

 return word;
}

// alinhamento da memória HEAP :-X

void *xmalloc(size_t size)
{
 register void *ptr=malloc(size);

 if(!ptr && size)
  puts("error in xmalloc()");

 return ptr;
}

static size_t WriteMemoryCallback(void *ptr,size_t size,size_t nmemb,void *data)
{
 size_t realsize=size*nmemb;
 struct MemoryStruct *mem=(struct MemoryStruct *)data;
 mem->memory=realloc(mem->memory,mem->size+realsize+1);
  if(mem->memory)
  {
   memcpy(&(mem->memory[mem->size]),ptr,realsize);
   mem->size+=realsize;
   mem->memory[mem->size]=0;
  }

 return realsize;
}