removed tabs and trailing whitespace from source

1 files changed, 198 insertions, 198 deletions

diff --git a/docs/examples/fopen.c b/docs/examples/fopen.c
index eb5501628..88729e72d 100644
--- a/docs/examples/fopen.c
+++ b/docs/examples/fopen.c
@@ -55,16 +55,16 @@ enum fcurl_type_e { CFTYPE_NONE=0, CFTYPE_FILE=1, CFTYPE_CURL=2 };
 
 struct fcurl_data
 {
-    enum fcurl_type_e type;	/* type of handle */
+    enum fcurl_type_e type;     /* type of handle */
     union {
-	CURL *curl;
-	FILE *file;
-    } handle;			/* handle */
-
-    char *buffer;		/* buffer to store cached data*/
-    int buffer_len;		/* currently allocated buffers length */
-    int buffer_pos;		/* end of data in buffer*/
-    int still_running;		/* Is background url fetch still in progress */
+        CURL *curl;
+        FILE *file;
+    } handle;                   /* handle */
+
+    char *buffer;               /* buffer to store cached data*/
+    int buffer_len;             /* currently allocated buffers length */
+    int buffer_pos;             /* end of data in buffer*/
+    int still_running;          /* Is background url fetch still in progress */
 };
 
 typedef struct fcurl_data URL_FILE;
@@ -83,9 +83,9 @@ CURLM *multi_handle;
 /* curl calls this routine to get more data */
 static size_t
 write_callback(char *buffer,
-	       size_t size,
-	       size_t nitems,
-	       void *userp)
+               size_t size,
+               size_t nitems,
+               void *userp)
 {
     char *newbuff;
     int rembuff;
@@ -97,21 +97,21 @@ write_callback(char *buffer,
 
     if(size > rembuff)
     {
-	//not enuf space in buffer
-	newbuff=realloc(url->buffer,url->buffer_len + (size - rembuff));
-	if(newbuff==NULL)
-	{
-	    fprintf(stderr,"callback buffer grow failed\n");
-	    size=rembuff;
-	}
-	else
-	{
-	    /* realloc suceeded increase buffer size*/
-	    url->buffer_len+=size - rembuff;
-	    url->buffer=newbuff;
-
-	    /*printf("Callback buffer grown to %d bytes\n",url->buffer_len);*/
-	}
+        //not enuf space in buffer
+        newbuff=realloc(url->buffer,url->buffer_len + (size - rembuff));
+        if(newbuff==NULL)
+        {
+            fprintf(stderr,"callback buffer grow failed\n");
+            size=rembuff;
+        }
+        else
+        {
+            /* realloc suceeded increase buffer size*/
+            url->buffer_len+=size - rembuff;
+            url->buffer=newbuff;
+
+            /*printf("Callback buffer grown to %d bytes\n",url->buffer_len);*/
+        }
     }
 
     memcpy(&url->buffer[url->buffer_pos], buffer, size);
@@ -137,42 +137,42 @@ curl_fill_buffer(URL_FILE *file,int want,int waittime)
      * doesnt exceed required size already
      */
     if((!file->still_running) || (file->buffer_pos > want))
-	return 0;
+        return 0;
 
     /* attempt to fill buffer */
     do
     {
-	FD_ZERO(&fdread);
-	FD_ZERO(&fdwrite);
-	FD_ZERO(&fdexcep);
+        FD_ZERO(&fdread);
+        FD_ZERO(&fdwrite);
+        FD_ZERO(&fdexcep);
 
-	/* set a suitable timeout to fail on */
-	timeout.tv_sec = 60; /* 1 minute */
-	timeout.tv_usec = 0;
+        /* set a suitable timeout to fail on */
+        timeout.tv_sec = 60; /* 1 minute */
+        timeout.tv_usec = 0;
 
-	/* get file descriptors from the transfers */
-	curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+        /* get file descriptors from the transfers */
+        curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
 
-	rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
+        rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
 
-	switch(rc) {
-	case -1:
-	    /* select error */
-	    break;
+        switch(rc) {
+        case -1:
+            /* select error */
+            break;
 
-	case 0:
-	    break;
+        case 0:
+            break;
 
-	default:
-	    /* timeout or readable/writable sockets */
-	    /* note we *could* be more efficient and not wait for
-	     * CURLM_CALL_MULTI_PERFORM to clear here and check it on re-entry
-	     * but that gets messy */
-	    while(curl_multi_perform(multi_handle, &file->still_running) ==
-		  CURLM_CALL_MULTI_PERFORM);
+        default:
+            /* timeout or readable/writable sockets */
+            /* note we *could* be more efficient and not wait for
+             * CURLM_CALL_MULTI_PERFORM to clear here and check it on re-entry
+             * but that gets messy */
+            while(curl_multi_perform(multi_handle, &file->still_running) ==
+                  CURLM_CALL_MULTI_PERFORM);
 
-	    break;
-	}
+            break;
+        }
     } while(file->still_running && (file->buffer_pos < want));
     return 1;
 }
@@ -184,22 +184,22 @@ curl_use_buffer(URL_FILE *file,int want)
     /* sort out buffer */
     if((file->buffer_pos - want) <=0)
     {
-	/* ditch buffer - write will recreate */
-	if(file->buffer)
-	    free(file->buffer);
+        /* ditch buffer - write will recreate */
+        if(file->buffer)
+            free(file->buffer);
 
-	file->buffer=NULL;
-	file->buffer_pos=0;
-	file->buffer_len=0;
+        file->buffer=NULL;
+        file->buffer_pos=0;
+        file->buffer_len=0;
     }
     else
     {
-	/* move rest down make it available for later */
-	memmove(file->buffer,
-		&file->buffer[want],
-		(file->buffer_pos - want));
+        /* move rest down make it available for later */
+        memmove(file->buffer,
+                &file->buffer[want],
+                (file->buffer_pos - want));
 
-	file->buffer_pos -= want;
+        file->buffer_pos -= want;
     }
     return 0;
 }
@@ -217,47 +217,47 @@ url_fopen(char *url,const char *operation)
 
     file = (URL_FILE *)malloc(sizeof(URL_FILE));
     if(!file)
-	return NULL;
+        return NULL;
 
     memset(file, 0, sizeof(URL_FILE));
 
     if((file->handle.file=fopen(url,operation)))
     {
-	file->type = CFTYPE_FILE; /* marked as URL */
+        file->type = CFTYPE_FILE; /* marked as URL */
     }
     else
     {
-	file->type = CFTYPE_CURL; /* marked as URL */
-	file->handle.curl = curl_easy_init();
+        file->type = CFTYPE_CURL; /* marked as URL */
+        file->handle.curl = curl_easy_init();
 
-	curl_easy_setopt(file->handle.curl, CURLOPT_URL, url);
-	curl_easy_setopt(file->handle.curl, CURLOPT_WRITEDATA, file);
-	curl_easy_setopt(file->handle.curl, CURLOPT_VERBOSE, FALSE);
-	curl_easy_setopt(file->handle.curl, CURLOPT_WRITEFUNCTION, write_callback);
+        curl_easy_setopt(file->handle.curl, CURLOPT_URL, url);
+        curl_easy_setopt(file->handle.curl, CURLOPT_WRITEDATA, file);
+        curl_easy_setopt(file->handle.curl, CURLOPT_VERBOSE, FALSE);
+        curl_easy_setopt(file->handle.curl, CURLOPT_WRITEFUNCTION, write_callback);
 
-	if(!multi_handle)
-	    multi_handle = curl_multi_init();
+        if(!multi_handle)
+            multi_handle = curl_multi_init();
 
-	curl_multi_add_handle(multi_handle, file->handle.curl);
+        curl_multi_add_handle(multi_handle, file->handle.curl);
 
-	/* lets start the fetch */
-	while(curl_multi_perform(multi_handle, &file->still_running) ==
-	      CURLM_CALL_MULTI_PERFORM );
+        /* lets start the fetch */
+        while(curl_multi_perform(multi_handle, &file->still_running) ==
+              CURLM_CALL_MULTI_PERFORM );
 
-	if((file->buffer_pos == 0) && (!file->still_running))
-	{
-	    /* if still_running is 0 now, we should return NULL */
+        if((file->buffer_pos == 0) && (!file->still_running))
+        {
+            /* if still_running is 0 now, we should return NULL */
 
-	    /* make sure the easy handle is not in the multi handle anymore */
-	    curl_multi_remove_handle(multi_handle, file->handle.curl);
+            /* make sure the easy handle is not in the multi handle anymore */
+            curl_multi_remove_handle(multi_handle, file->handle.curl);
 
-	    /* cleanup */
-	    curl_easy_cleanup(file->handle.curl);
+            /* cleanup */
+            curl_easy_cleanup(file->handle.curl);
 
-	    free(file);
+            free(file);
 
-	    file = NULL;
-	}
+            file = NULL;
+        }
     }
     return file;
 }
@@ -270,26 +270,26 @@ url_fclose(URL_FILE *file)
     switch(file->type)
     {
     case CFTYPE_FILE:
-	ret=fclose(file->handle.file); /* passthrough */
-	break;
+        ret=fclose(file->handle.file); /* passthrough */
+        break;
 
     case CFTYPE_CURL:
-	/* make sure the easy handle is not in the multi handle anymore */
-	curl_multi_remove_handle(multi_handle, file->handle.curl);
+        /* make sure the easy handle is not in the multi handle anymore */
+        curl_multi_remove_handle(multi_handle, file->handle.curl);
 
-	/* cleanup */
-	curl_easy_cleanup(file->handle.curl);
-	break;
+        /* cleanup */
+        curl_easy_cleanup(file->handle.curl);
+        break;
 
     default: /* unknown or supported type - oh dear */
-	ret=EOF;
-	errno=EBADF;
-	break;
+        ret=EOF;
+        errno=EBADF;
+        break;
 
     }
 
     if(file->buffer)
-	free(file->buffer);/* free any allocated buffer space */
+        free(file->buffer);/* free any allocated buffer space */
 
     free(file);
 
@@ -304,17 +304,17 @@ url_feof(URL_FILE *file)
     switch(file->type)
     {
     case CFTYPE_FILE:
-	ret=feof(file->handle.file);
-	break;
+        ret=feof(file->handle.file);
+        break;
 
     case CFTYPE_CURL:
-	if((file->buffer_pos == 0) && (!file->still_running))
-	    ret = 1;
-	break;
+        if((file->buffer_pos == 0) && (!file->still_running))
+            ret = 1;
+        break;
     default: /* unknown or supported type - oh dear */
-	ret=-1;
-	errno=EBADF;
-	break;
+        ret=-1;
+        errno=EBADF;
+        break;
     }
     return ret;
 }
@@ -327,38 +327,38 @@ url_fread(void *ptr, size_t size, size_t nmemb, URL_FILE *file)
     switch(file->type)
     {
     case CFTYPE_FILE:
-	want=fread(ptr,size,nmemb,file->handle.file);
-	break;
+        want=fread(ptr,size,nmemb,file->handle.file);
+        break;
 
     case CFTYPE_CURL:
-	want = nmemb * size;
+        want = nmemb * size;
 
-	curl_fill_buffer(file,want,1);
+        curl_fill_buffer(file,want,1);
 
-	/* check if theres data in the buffer - if not curl_fill_buffer()
-	 * either errored or EOF */
-	if(!file->buffer_pos)
-	    return 0;
+        /* check if theres data in the buffer - if not curl_fill_buffer()
+         * either errored or EOF */
+        if(!file->buffer_pos)
+            return 0;
 
-	/* ensure only available data is considered */
-	if(file->buffer_pos < want)
-	    want = file->buffer_pos;
+        /* ensure only available data is considered */
+        if(file->buffer_pos < want)
+            want = file->buffer_pos;
 
-	/* xfer data to caller */
-	memcpy(ptr, file->buffer, want);
+        /* xfer data to caller */
+        memcpy(ptr, file->buffer, want);
 
-	curl_use_buffer(file,want);
+        curl_use_buffer(file,want);
 
-	want = want / size;	/* number of items - nb correct op - checked
-				 * with glibc code*/
+        want = want / size;     /* number of items - nb correct op - checked
+                                 * with glibc code*/
 
-	/*printf("(fread) return %d bytes %d left\n", want,file->buffer_pos);*/
-	break;
+        /*printf("(fread) return %d bytes %d left\n", want,file->buffer_pos);*/
+        break;
 
     default: /* unknown or supported type - oh dear */
-	want=0;
-	errno=EBADF;
-	break;
+        want=0;
+        errno=EBADF;
+        break;
 
     }
     return want;
@@ -373,45 +373,45 @@ url_fgets(char *ptr, int size, URL_FILE *file)
     switch(file->type)
     {
     case CFTYPE_FILE:
-	ptr = fgets(ptr,size,file->handle.file);
-	break;
+        ptr = fgets(ptr,size,file->handle.file);
+        break;
 
     case CFTYPE_CURL:
-	curl_fill_buffer(file,want,1);
+        curl_fill_buffer(file,want,1);
 
-	/* check if theres data in the buffer - if not fill either errored or
-	 * EOF */
-	if(!file->buffer_pos)
-	    return NULL;
+        /* check if theres data in the buffer - if not fill either errored or
+         * EOF */
+        if(!file->buffer_pos)
+            return NULL;
 
-	/* ensure only available data is considered */
-	if(file->buffer_pos < want)
-	    want = file->buffer_pos;
+        /* ensure only available data is considered */
+        if(file->buffer_pos < want)
+            want = file->buffer_pos;
 
-	/*buffer contains data */
-	/* look for newline or eof */
-	for(loop=0;loop < want;loop++)
-	{
-	    if(file->buffer[loop] == '\n')
-	    {
-		want=loop+1;/* include newline */
-		break;
-	    }
-	}
+        /*buffer contains data */
+        /* look for newline or eof */
+        for(loop=0;loop < want;loop++)
+        {
+            if(file->buffer[loop] == '\n')
+            {
+                want=loop+1;/* include newline */
+                break;
+            }
+        }
 
-	/* xfer data to caller */
-	memcpy(ptr, file->buffer, want);
-	ptr[want]=0;/* allways null terminate */
+        /* xfer data to caller */
+        memcpy(ptr, file->buffer, want);
+        ptr[want]=0;/* allways null terminate */
 
-	curl_use_buffer(file,want);
+        curl_use_buffer(file,want);
 
-	/*printf("(fgets) return %d bytes %d left\n", want,file->buffer_pos);*/
-	break;
+        /*printf("(fgets) return %d bytes %d left\n", want,file->buffer_pos);*/
+        break;
 
     default: /* unknown or supported type - oh dear */
-	ptr=NULL;
-	errno=EBADF;
-	break;
+        ptr=NULL;
+        errno=EBADF;
+        break;
     }
 
     return ptr;/*success */
@@ -423,28 +423,28 @@ url_rewind(URL_FILE *file)
     switch(file->type)
     {
     case CFTYPE_FILE:
-	rewind(file->handle.file); /* passthrough */
-	break;
+        rewind(file->handle.file); /* passthrough */
+        break;
 
     case CFTYPE_CURL:
-	/* halt transaction */
-	curl_multi_remove_handle(multi_handle, file->handle.curl);
+        /* halt transaction */
+        curl_multi_remove_handle(multi_handle, file->handle.curl);
 
-	/* restart */
-	curl_multi_add_handle(multi_handle, file->handle.curl);
+        /* restart */
+        curl_multi_add_handle(multi_handle, file->handle.curl);
 
-	/* ditch buffer - write will recreate - resets stream pos*/
-	if(file->buffer)
-	    free(file->buffer);
+        /* ditch buffer - write will recreate - resets stream pos*/
+        if(file->buffer)
+            free(file->buffer);
 
-	file->buffer=NULL;
-	file->buffer_pos=0;
-	file->buffer_len=0;
+        file->buffer=NULL;
+        file->buffer_pos=0;
+        file->buffer_len=0;
 
-	break;
+        break;
 
     default: /* unknown or supported type - oh dear */
-	break;
+        break;
 
     }
 
@@ -466,33 +466,33 @@ main(int argc, char *argv[])
 
     if(argc < 2)
     {
-	url="http://192.168.7.3/testfile";/* default to testurl */
+        url="http://192.168.7.3/testfile";/* default to testurl */
     }
     else
     {
-	url=argv[1];/* use passed url */
+        url=argv[1];/* use passed url */
     }
 
     /* copy from url line by line with fgets */
     outf=fopen("fgets.test","w+");
     if(!outf)
     {
-	perror("couldnt open fgets output file\n");
-	return 1;
+        perror("couldnt open fgets output file\n");
+        return 1;
     }
 
     handle = url_fopen(url, "r");
     if(!handle)
     {
-	printf("couldn't url_fopen()\n");
-	fclose(outf);
-	return 2;
+        printf("couldn't url_fopen()\n");
+        fclose(outf);
+        return 2;
     }
 
     while(!url_feof(handle))
     {
-	url_fgets(buffer,sizeof(buffer),handle);
-	fwrite(buffer,1,strlen(buffer),outf);
+        url_fgets(buffer,sizeof(buffer),handle);
+        fwrite(buffer,1,strlen(buffer),outf);
     }
 
     url_fclose(handle);
@@ -504,20 +504,20 @@ main(int argc, char *argv[])
     outf=fopen("fread.test","w+");
     if(!outf)
     {
-	perror("couldnt open fread output file\n");
-	return 1;
+        perror("couldnt open fread output file\n");
+        return 1;
     }
 
     handle = url_fopen("testfile", "r");
     if(!handle) {
-	printf("couldn't url_fopen()\n");
-	fclose(outf);
-	return 2;
+        printf("couldn't url_fopen()\n");
+        fclose(outf);
+        return 2;
     }
 
     do {
-	nread = url_fread(buffer, 1,sizeof(buffer), handle);
-	fwrite(buffer,1,nread,outf);
+        nread = url_fread(buffer, 1,sizeof(buffer), handle);
+        fwrite(buffer,1,nread,outf);
     } while(nread);
 
     url_fclose(handle);
@@ -529,26 +529,26 @@ main(int argc, char *argv[])
     outf=fopen("rewind.test","w+");
     if(!outf)
     {
-	perror("couldnt open fread output file\n");
-	return 1;
+        perror("couldnt open fread output file\n");
+        return 1;
     }
 
     handle = url_fopen("testfile", "r");
     if(!handle) {
-	printf("couldn't url_fopen()\n");
-	fclose(outf);
-	return 2;
+        printf("couldn't url_fopen()\n");
+        fclose(outf);
+        return 2;
     }
 
-	nread = url_fread(buffer, 1,sizeof(buffer), handle);
-	fwrite(buffer,1,nread,outf);
-	url_rewind(handle);
+        nread = url_fread(buffer, 1,sizeof(buffer), handle);
+        fwrite(buffer,1,nread,outf);
+        url_rewind(handle);
 
-	buffer[0]='\n';
-	fwrite(buffer,1,1,outf);
+        buffer[0]='\n';
+        fwrite(buffer,1,1,outf);
 
-	nread = url_fread(buffer, 1,sizeof(buffer), handle);
-	fwrite(buffer,1,nread,outf);
+        nread = url_fread(buffer, 1,sizeof(buffer), handle);
+        fwrite(buffer,1,nread,outf);
 
 
     url_fclose(handle);