Every file in this commit has a memory leak of some kind or another. I think

all of them are minor and should not effect properly running code. But if I
were you I would give libstocks and the stockticker plugin in Today a wide
berth. That library is atrocious.

9 files changed, 246 insertions, 157 deletions

diff --git a/noncore/apps/opie-reader/Bkmks.cpp b/noncore/apps/opie-reader/Bkmks.cpp
index 00141a3..45aa045 100644
--- a/noncore/apps/opie-reader/Bkmks.cpp
+++ b/noncore/apps/opie-reader/Bkmks.cpp
@@ -334,24 +334,25 @@ Bkmk* BkmkFile::read05(BkmkFile* /*_this*/, FILE* f)
 	if (fread(&ln,sizeof(ln),1,f) == 1)
 	{
 	    tchar* nm = new tchar[ln+1];
 	    fread(nm,sizeof(tchar),ln,f);
 	    nm[ln] = 0;
 	    fread(&ln,sizeof(ln),1,f);
 	    tchar* anno = new tchar[ln+1];
 	    if (ln > 0) fread(anno,sizeof(tchar),ln,f);
 	    anno[ln] = 0;
 	    unsigned int pos;
 	    fread(&pos,sizeof(pos),1,f);
 	    b = new Bkmk(nm,anno,pos);
+	    delete [] anno;
 	}
     }
     return b;
 }
 
 Bkmk* BkmkFile::read06(BkmkFile* /*_this*/, FILE* f)
 {
     Bkmk* b = NULL;
     if (f != NULL)
     {
 	unsigned short ln;
 	if (fread(&ln,sizeof(ln),1,f) == 1)
diff --git a/noncore/apps/opie-sheet/Excel.cpp b/noncore/apps/opie-sheet/Excel.cpp
index 51fe707..27080e9 100644
--- a/noncore/apps/opie-sheet/Excel.cpp
+++ b/noncore/apps/opie-sheet/Excel.cpp
@@ -368,25 +368,27 @@ ExcelBREC* ExcelBook::PeekBREC(void)
     int oldpos;
     ExcelBREC* NextRec;
     oldpos=Position;
     NextRec=GetBREC();
     SeekPosition(oldpos);
     return NextRec;
 };
 
 char* ExcelBook::GetDataOfBREC(ExcelBREC* record)
 {
     if(record->data==NULL)
     {
-        ConvertCharToArray(record,Read(record->position,record->length),record->length);
+	char* readData = Read(record->position,record->length);
+        ConvertCharToArray(record,readData,record->length);
+	delete [] readData;
     };
     return record->data;//new?
 };
 
 void ExcelBook::ConvertCharToArray(ExcelBREC* record, char* chars, int length)
 {
     record->data=new char[length];
     for(int w1=0;w1<=length-1;w1++)
         record->data[w1]=chars[w1];
 };
 
 
diff --git a/noncore/apps/zsafe/zsafe.cpp b/noncore/apps/zsafe/zsafe.cpp
index f70f863..9c0c6ce 100644
--- a/noncore/apps/zsafe/zsafe.cpp
+++ b/noncore/apps/zsafe/zsafe.cpp
@@ -1759,85 +1759,91 @@ bool ZSafe::openDocument(const char* _filename, const char* )
 int ZSafe::loadInit(const char* _filename, const char *password)
 {
     unsigned int j = 0;
     unsigned int keylength=0;
     int count=0, count2=0, count3=0;
     unsigned char charbuf[8];
     unsigned short ciphertext[4];
     char key[128];
     Krc2* krc2 = new Krc2();
 
     fd = fopen (_filename, "rb");
 
-        QFileInfo f (_filename);
-        load_buffer_length = f.size();
-        load_buffer_length = ((load_buffer_length / 1024)+1) * 1024 * 2;
+    QFileInfo f (_filename);
+    load_buffer_length = f.size();
+    load_buffer_length = ((load_buffer_length / 1024)+1) * 1024 * 2;
 
-    if (fd == NULL)
+    if (fd == NULL) {
+        delete krc2;
         return PWERR_OPEN;
+    }
 
     buffer = (char *)malloc(load_buffer_length);
     for (j = 0; password[j] != '\0'; j++) {
         key[j] = password[j];
     }
     keylength = j;
     krc2->rc2_expandkey (key, keylength, 128);
 
 #ifndef Q_WS_WIN
     size = read(fileno (fd), (unsigned char *) (charbuf + count), 8);
 #else
     size = fread ((unsigned char *) (charbuf + count), sizeof(unsigned char), 8, fd);
 #endif
 
-    if (size < 8)
+    if (size < 8) {
+        delete krc2;
         return PWERR_DATA;
+    }
 
     for (count = 0; count < 4; count++) {
         count2 = count << 1;
         iv[count] = charbuf[count2] << 8;
         iv[count] += charbuf[count2 + 1];
     }
 
     size = 0;
     bufferIndex = 0;
 #ifndef Q_WS_WIN
     while ((count = read (fileno (fd), (unsigned char *) charbuf, 8)) > 0) {
         while (count < 8) {
             count2 = read (fileno (fd), (unsigned char *) (charbuf + count), 8);
 #else
     while ((count = fread ((unsigned char *) (charbuf), sizeof(unsigned char), 8, fd)) > 0) {
         while (count < 8) {
             count2 = fread ((unsigned char *) (charbuf + count), sizeof(unsigned char), 8, fd);
 #endif
             if (count2 == 0) {
+                delete krc2;
                 return PWERR_DATA;
             }
             count += count2;
         } /* while (count < 8) */
 
         size += 8;
         for (count2 = 0; count2 < 8; count2 += 2) {
             count3 = count2 >> 1;
             ciphertext[count3] = charbuf[count2] << 8;
             ciphertext[count3] += charbuf[count2 + 1];
 
             plaintext[count3] = ciphertext[count3] ^ iv[count3];
             iv[count3] = plaintext[count3];
         } /* for (count2) */
 
         krc2->rc2_decrypt (plaintext);
         memcpy ((unsigned char *) (buffer + bufferIndex), plaintext, 8);
         bufferIndex += 8;
         buffer[bufferIndex + 1] = '\0';
     } /* while ((count = read (fileno (fd), (unsigned char *) charbuf, 8)) > 0) */
+    delete krc2;
     size -= buffer[size - 1];
     lastcount = 0;
 
     /* This will point to the starting index */
     bufferIndex = 0;
     return PWERR_GOOD;
 }
 
 int ZSafe::loadEntry(char *entry[FIELD_SIZE])
 {
     /* Strip off PKCS 5 padding
      * Should check to make sure it's good here
@@ -2090,55 +2096,43 @@ void ZSafe::getDocPassword(QString title)
     }
 }
 
 int ZSafe::saveInit(const char *_filename, const char *password)
 {
     char key[128];
     unsigned int j = 0;
     unsigned int keylength;
     // int val;
     int count2;
     Krc2* krc2 = new Krc2();
 
-    /* first we should check the permissions of the filename */
-/*
-    if (QFile::exists(_filename)) {
-        val = checkFile(_filename);
-        if (val != PWERR_GOOD)
-            return val;
-    } else
-        {
-        val = creat (_filename, (S_IRUSR | S_IWUSR));
-        if (val == -1)
-            return PWERR_OPEN;
-        else
-            close(val);
-    }
-*/
-        QFileInfo f (_filename);
-        save_buffer_length = f.size();
-        save_buffer_length = ((save_buffer_length / 1024)+1) * 1024;
+    QFileInfo f (_filename);
+    save_buffer_length = f.size();
+    save_buffer_length = ((save_buffer_length / 1024)+1) * 1024;
 
     fd = fopen (_filename, "wb");
-    if (fd == NULL)
+    if (fd == NULL) {
+        delete krc2;
         return PWERR_OPEN;
+    }
 
     buffer = (char*)malloc(save_buffer_length);
 
     /* make the key ready */
     for (j = 0; password[j] != '\0'; j++) {
         key[j] = password[j];
     }
     keylength = j;
     krc2->rc2_expandkey (key, keylength, 128);
+    delete krc2;
 
     /* First, we make the IV */
     for (count2 = 0; count2 < 4; count2++) {
         iv[count2] = rand ();
         putc ((unsigned char) (iv[count2] >> 8), fd);
         putc ((unsigned char) (iv[count2] & 0xff), fd);
     }
 
     bufferIndex = 0;
     return PWERR_GOOD;
 }
 
@@ -2179,33 +2173,39 @@ int ZSafe::saveEntry(char *entry[FIELD_SIZE])
         bufferIndex++;
         if (bufferIndex == 4) {
             krc2->rc2_encrypt (plaintext);
 
             for (count3 = 0; count3 < 4; count3++) {
                 ciphertext[count3] = iv[count3] ^ plaintext[count3];
 
                 /* Now store the ciphertext as the iv */
                 iv[count3] = plaintext[count3];
 
                 /* reset the buffer index */
                 bufferIndex = 0;
-                if (putc ((unsigned char) (ciphertext[count3] >> 8), fd) == EOF) return PWERR_DATA;
-                if (putc ((unsigned char) (ciphertext[count3] & 0xff), fd) == EOF) return PWERR_DATA;
+                if (putc ((unsigned char) (ciphertext[count3] >> 8), fd) == EOF) {
+                    delete krc2;
+		    return PWERR_DATA;
+                }
+                if (putc ((unsigned char) (ciphertext[count3] & 0xff), fd) == EOF) {
+                    delete krc2;
+		    return PWERR_DATA;
+                }
             } /*for (count3 = 0; count3 < 5; count3++)*/
         } /*if (bufferIndex == 5)*/
         /* increment a short, not a byte */
         count2 += 2;
     } /*while (count2 < strlen (buffer))*/
-        int ret = PWERR_GOOD;
-    return ret;
+    delete krc2;
+    return PWERR_GOOD;
 }
 
 int ZSafe::saveFinalize(void)
 {
     int count1, retval = PWERR_GOOD;
     unsigned short ciphertext[4];
     Krc2* krc2 = new Krc2();
 
     /* Tack on the PKCS 5 padding
      * How it works is we fill up the last n bytes with the value n
      *
      * So, if we have, say, 13 bytes, 8 of which are used, we have 5 left
@@ -2219,24 +2219,25 @@ int ZSafe::saveFinalize(void)
     for (count1 = bufferIndex; count1 < 4; count1++) {
         plaintext[count1] = (4 - bufferIndex);
     }
     krc2->rc2_encrypt (plaintext);
     for (count1 = 0; count1 < 4; count1++) {
         ciphertext[count1] = iv[count1] ^ plaintext[count1];
         if (putc ((unsigned char) (ciphertext[count1] >> 8), fd) == EOF) retval = PWERR_DATA;
         if (putc ((unsigned char) (ciphertext[count1] & 0xff), fd) == EOF) retval = PWERR_DATA;
     }
 
     fclose (fd);
     free(buffer);
+    delete krc2;
     return retval;
 }
 
 void ZSafe::quitMe ()
 {
     if (modified)
     {
       switch( QMessageBox::information( this, tr("ZSafe"),
                                       tr("Do you want to save\nbefore exiting?"),
                                       tr("&Save"),
                                       tr("S&ave with\nnew\npassword"),
                                       tr("&Don't Save"),
diff --git a/noncore/comm/keypebble/vncauth.c b/noncore/comm/keypebble/vncauth.c
index 277d145..7de837a 100644
--- a/noncore/comm/keypebble/vncauth.c
+++ b/noncore/comm/keypebble/vncauth.c
@@ -85,30 +85,34 @@ vncEncryptAndStorePasswd(char *passwd, char *fname)
  * Decrypt a password from a file.  Returns a pointer to a newly allocated
  * string containing the password or a null pointer if the password could
  * not be retrieved for some reason.
  */
 
 char *
 vncDecryptPasswdFromFile(char *fname)
 {
     FILE *fp;
     int i, ch;
     unsigned char *passwd = (unsigned char *)malloc(9);
 
-    if ((fp = fopen(fname,"r")) == NULL) return NULL;
+    if ((fp = fopen(fname,"r")) == NULL) {
+	free(passwd);
+        return NULL;
+    }
 
     for (i = 0; i < 8; i++) {
 	ch = getc(fp);
 	if (ch == EOF) {
 	    fclose(fp);
+	    free(passwd);
 	    return NULL;
 	}
 	passwd[i] = ch;
     }
 
     deskey(fixedkey, DE1);
     des(passwd, passwd);
 
     passwd[8] = 0;
 
     return (char *)passwd;
 }
diff --git a/noncore/net/ftplib/ftplib.c b/noncore/net/ftplib/ftplib.c
index efcd6f0..addf9d2 100644
--- a/noncore/net/ftplib/ftplib.c
+++ b/noncore/net/ftplib/ftplib.c
@@ -1163,25 +1163,29 @@ static int FtpXfer(const char *localfile, const char *path,
               ac[1] = 'b';
           local = fopen(localfile, ac);
           if (local == NULL)
             {
                 strncpy(nControl->response, strerror(errno),
                         sizeof(nControl->response));
                 return 0;
             }
       }
     if (local == NULL)
         local = (typ == FTPLIB_FILE_WRITE) ? stdin : stdout;
     if (!FtpAccess(path, typ, mode, nControl, &nData))
+      {
+        if (localfile != NULL)
+            fclose(local);
         return 0;
+      }
     dbuf = malloc(FTPLIB_BUFSIZ);
     if (typ == FTPLIB_FILE_WRITE)
       {
           while ((l = fread(dbuf, 1, FTPLIB_BUFSIZ, local)) > 0)
               if ((c = FtpWrite(dbuf, l, nData)) < l)
                 {
                     printf("short write: passed %d, wrote %d\n", l, c);
                     rv = 0;
                     break;
                 }
       }
     else
diff --git a/noncore/todayplugins/stockticker/libstocks/csv.c b/noncore/todayplugins/stockticker/libstocks/csv.c
index 86d8607..110df7c 100644
--- a/noncore/todayplugins/stockticker/libstocks/csv.c
+++ b/noncore/todayplugins/stockticker/libstocks/csv.c
@@ -132,102 +132,142 @@ stock *parse_csv_file(char *csv)
   {
     valid ++;
     test = test +3;
   }
       
       if (valid < 6)
   {
     /* This Symbol is valid */
 
     StockPtr = malloc_stock();
     
     ptr = csv_strtok(line, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
 
     symbol = (char *)malloc(strlen(ptr)+1);
     if (symbol==NULL)
       {
         fprintf(stderr,"Memory allocating error (%s line %d)\n"
           ,__FILE__, __LINE__);
         exit(1);
       }
     strcpy((char *)(symbol), ptr);
     StockPtr->Symbol = symbol;
 
     ptr = csv_strtok(NULL, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
 
     name = (char *)malloc(strlen(ptr)+1);
     if (name==NULL)
       {
         fprintf(stderr,"Memory allocating error (%s line %d)\n"
           ,__FILE__, __LINE__);
         exit(1);
       }
     strcpy((char *)(name), ptr);
     StockPtr->Name = name;
 
     ptr = csv_strtok(NULL, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
     sscanf(ptr,"%f",&(StockPtr->CurrentPrice));
 
     ptr = csv_strtok(NULL, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
 
     date = (char *)malloc(strlen(ptr)+1);
     if (date==NULL)
       {
         fprintf(stderr,"Memory allocating error (%s line %d)\n"
           ,__FILE__, __LINE__);
         exit(1);
       }
     strcpy((char *)(date), ptr);
     StockPtr->Date = date;
 
     ptr = csv_strtok(NULL, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
 
     time = (char *)malloc(strlen(ptr)+1);
     if (time==NULL)
       {
         fprintf(stderr,"Memory allocating error (%s line %d)\n"
           ,__FILE__, __LINE__);
         exit(1);
       }
     strcpy((char *)(time), ptr);
     StockPtr->Time = time;
     
     ptr = csv_strtok(NULL, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
     sscanf(ptr,"%f",&(StockPtr->Variation));      
     
     StockPtr->Pourcentage = 100 * StockPtr->Variation /
       (StockPtr->CurrentPrice - StockPtr->Variation);
 
     StockPtr->LastPrice = StockPtr->CurrentPrice - StockPtr->Variation;
 
     ptr = csv_strtok(NULL, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
     sscanf(ptr,"%f",&(StockPtr->OpenPrice));      
 
     ptr = csv_strtok(NULL, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
     sscanf(ptr,"%f",&(StockPtr->MaxPrice));      
 
     ptr = csv_strtok(NULL, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
     sscanf(ptr,"%f",&(StockPtr->MinPrice));      
   
     ptr = csv_strtok(NULL, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
     StockPtr->Volume = atoi(ptr);
 
     if( !FirstStockPtr ) 
       {
         FirstStockPtr = StockPtr;
         StockPtr->PreviousStock = 0;
       }
     
     StockPtr->NextStock = 0;
   
     if (LastStockPtr) 
       {
@@ -238,25 +278,29 @@ stock *parse_csv_file(char *csv)
     LastStockPtr = StockPtr;
     
   }
       else
   {
     /* this symbol is not valid */
     /* Set the stock struct just with Symbol, all other are NULL */
     /* This can be used to see if the symbol has been reached are not */
 
     StockPtr = malloc_stock();
     
     ptr = csv_strtok(line, ",");
-    if (!ptr) return 0;
+    if (!ptr)
+      {
+        free_stock(StockPtr);
+        return 0;
+      }
 
     symbol = (char *)malloc(strlen(ptr)+1);
     if (symbol==NULL)
       {
         fprintf(stderr,"Memory allocating error (%s line %d)\n"
           ,__FILE__, __LINE__);
         exit(1);
       }
     strcpy((char *)(symbol), ptr);
     StockPtr->Symbol = symbol;
 
     if( !FirstStockPtr ) 
@@ -319,88 +363,118 @@ stock *parse_csv_history_file(char *csv_file)
   *end_line = 0;
   end_line++;
   line = end_line;
 
   while ((end_line = strstr(line, "\n")))
     {
       *end_line = 0;
 
       StockPtr = malloc_stock();
     
       /* Date */
       ptr = strtok(line, ",");
-      if (!ptr) return 0;
+      if (!ptr)
+        {
+          free_stock(StockPtr);
+          free_stock(FirstStockPtr);
+          free_stock(LastStockPtr);
+          return 0;
+	}
 
       sscanf(ptr,"%d-%3s-%d",&day,smonth,&year);
 
       i=0;
 
 #ifdef __UNIX__
       while((test=strcasecmp(months[i], smonth))) i++;
 #elif __WINDOWS__
       while(test=_mbsnbicmp(months[i], smonth, strlen(months[i]))) i++;
 #endif
 
       month = i+1;
 
       date = (char *)malloc(DATE_LENGTH);
       if (date==NULL)
-  {
-    fprintf(stderr,"Memory allocating error (%s line %d)\n"
-      ,__FILE__, __LINE__);
-    exit(1);
-  }
+        {
+          fprintf(stderr,"Memory allocating error (%s line %d)\n"
+                  ,__FILE__, __LINE__);
+          exit(1);
+        }
       sprintf(date,"%.2d%.2d%.2d", year, month, day);
       StockPtr->Date = date;    
       
       /* Open */
       ptr = strtok(NULL, ",");
-      if (!ptr) return 0;
+      if (!ptr)
+        {
+          free_stock(StockPtr);
+          free_stock(FirstStockPtr);
+          free_stock(LastStockPtr);
+          return 0;
+        }
       sscanf(ptr,"%f",&(StockPtr->OpenPrice));      
 
       /* High */
       ptr = strtok(NULL, ",");
-      if (!ptr) return 0;
+      if (!ptr)
+        {
+          free_stock(StockPtr);
+          free_stock(FirstStockPtr);
+          free_stock(LastStockPtr);
+          return 0;
+        }
       sscanf(ptr,"%f",&(StockPtr->MaxPrice));
 
       /* Low */
       ptr = strtok(NULL, ",");
-      if (!ptr) return 0;
+      if (!ptr)
+        {
+          free_stock(StockPtr);
+          free_stock(FirstStockPtr);
+          free_stock(LastStockPtr);
+          return 0;
+        }
       sscanf(ptr,"%f",&(StockPtr->MinPrice));
 
       /* Close */
       ptr = strtok(NULL, ",");
-      if (!ptr) return 0;
+      if (!ptr)
+        {
+          free_stock(StockPtr);
+          free_stock(FirstStockPtr);
+          free_stock(LastStockPtr);
+          return 0;
+        }
       sscanf(ptr,"%f",&(StockPtr->LastPrice));
 
       /* Volume */
 
       ptr = strtok(NULL, ",");
       if (!ptr) 
-  /* It seems to be an indice */
-  /* No volume for indices */
-  StockPtr->Volume = 0;
+          /* It seems to be an indice */
+          /* No volume for indices */
+          StockPtr->Volume = 0;
       else
-  StockPtr->Volume = atoi(ptr);
+          StockPtr->Volume = atoi(ptr);
 
       if( !FirstStockPtr ) 
-  {
-    FirstStockPtr = StockPtr;
-    StockPtr->PreviousStock = 0;
-  }
+        {
+          FirstStockPtr = StockPtr;
+          StockPtr->PreviousStock = 0;
+        }
       
       StockPtr->NextStock = 0;
       
       if (LastStockPtr) 
-  {
-    LastStockPtr->NextStock = StockPtr;
-    StockPtr->PreviousStock = LastStockPtr;
-  }
+        {
+          LastStockPtr->NextStock = StockPtr;
+          StockPtr->PreviousStock = LastStockPtr;
+        }
       
       LastStockPtr = StockPtr;
 
       end_line++;
       line = end_line;       
     }
     
   return (FirstStockPtr);
 }
diff --git a/noncore/todayplugins/stockticker/libstocks/currency.c b/noncore/todayplugins/stockticker/libstocks/currency.c
index 9a08a9d..e0090e2 100644
--- a/noncore/todayplugins/stockticker/libstocks/currency.c
+++ b/noncore/todayplugins/stockticker/libstocks/currency.c
@@ -43,24 +43,25 @@ libstocks_return_code get_currency_exchange(char *from,
   if((symbol = (char *)malloc(strlen(from)+strlen(into)+3))==NULL)
     {
       fprintf(stderr,"Memory allocating error (%s line %d)\n"
 	      ,__FILE__, __LINE__);
       exit(1);
     }
 
   strcpy(symbol, from);
   strcat(symbol, into);
   strcat(symbol, "=X");
   
   error = get_stocks(symbol, &data);
+  free(symbol);
   if (error) 
     {
       *exchange = 0;
       return(error);
     }
 
   free_stocks(data);
 
   *exchange = data->CurrentPrice;
   return(error);
  
 }
diff --git a/noncore/todayplugins/stockticker/libstocks/lists.h b/noncore/todayplugins/stockticker/libstocks/lists.h
index 0132317..a0eb434 100644
--- a/noncore/todayplugins/stockticker/libstocks/lists.h
+++ b/noncore/todayplugins/stockticker/libstocks/lists.h
@@ -21,15 +21,16 @@
 #ifndef __LISTS_H__
 #define __LISTS_H__
 
 #ifndef __LISTS_C__
 #define PUBEXT_LISTS extern
 #else
 #define PUBEXT_LISTS
 #endif
 
 #include "stocks.h"
 
 PUBEXT_LISTS  stock *malloc_stock(void); 
+PUBEXT_LISTS  void   free_stock(stock*);
 
 
 #endif /* __LISTS_H */
diff --git a/noncore/todayplugins/stockticker/libstocks/stocks.c b/noncore/todayplugins/stockticker/libstocks/stocks.c
index eb04ba9..3a26a47 100644
--- a/noncore/todayplugins/stockticker/libstocks/stocks.c
+++ b/noncore/todayplugins/stockticker/libstocks/stocks.c
@@ -96,90 +96,90 @@ yahoo_source find_yahoo_source(char *symbol)
   /* Test if it is canadian stock */
   for (i=0; i<YAHOO_US_EXT_NB; i++)
     {
 
 #ifdef __UNIX__
       test = strcasecmp(yahoo_us_ext[i], ptr);
 #elif __WINDOWS__
       test = _mbsnbicmp(yahoo_us_ext[i], ptr, strlen(yahoo_us_ext[i]));
 #endif
 
       if (!test) return YAHOO_US;
     }
-  
+
   /* We suppose now it is a European stock */
   return YAHOO_EUROPE;
 }
 
 /*****************************************************************************/
 /* Gets quotes csv file, parses the file and create the quotes list          */
 /* *stocks points to the stocks to fetch                                     */
 /* *stock_datas points to the beginning of the list                          */
 /* count allows to connect to all country servers                            */
 /*****************************************************************************/
-libstocks_return_code download_stocks(char *stocks, 
-              stock **stock_datas, 
+libstocks_return_code download_stocks(char *stocks,
+              stock **stock_datas,
               yahoo_source source)
 {
   char *stocks_server=NULL;
   char *url_beg=NULL;
   char *url_end=NULL;
 
   char *url;
   char *data;
 
   libstocks_return_code error;
 
 #ifdef DEBUG
   printf("*download_stocks\n");
 #endif
 
   switch (source)
     {
     case YAHOO_US:
       stocks_server = (char *)yahoo_us_stocks_server;
       break;
-      
+
     case YAHOO_EUROPE:
       stocks_server = (char *)yahoo_eu_stocks_server;
       break;
       default:
       stocks_server = (char *)yahoo_us_stocks_server;
     break;
-          
+
     }
 
   url_beg = (char *)yahoo_url_beg;
   url_end = (char *)yahoo_url_end;
 
   url = (char *)malloc(strlen(url_beg)
            +strlen(url_end)
            +strlen(stocks)+1);
   if (url==NULL)
     {
       fprintf(stderr,"Memory allocating error (%s line %d)\n"
         ,__FILE__, __LINE__);
       exit(1);
     }
 
   strcpy(url, url_beg);
   strcat(url, stocks);
   strcat(url, url_end);
-  
+
   error=http_get(url, stocks_server, &data);
- 
+
   free(url);
 
   if (error) return error;
-  
+
   *stock_datas = parse_csv_file(data);
 
   free(data);
 
   if (!(*stock_datas)) return ERRPCSV;
 
   return 0;
 
 }
 
 /*****************************************************************************/
 /* Gets quotes from yahoo                                                    */
@@ -213,135 +213,136 @@ libstocks_return_code get_stocks(const char *stocks, stock **stock_datas)
   stock *last_stock=NULL;
 
 #ifdef DEBUG
   printf("*get_stocks\n");
 #endif
 
   /* to preserve stocks */
   tok_ptr = malloc(strlen(stocks)+1);
   if(tok_ptr==NULL)
     {
       fprintf(stderr,"Memory allocating error (%s line %d)\n"
         ,__FILE__, __LINE__);
-      exit(1);  
+      exit(1);
     }
   strcpy(tok_ptr, stocks);
 
   while( (symbol = strtok(tok_ptr, "+"))!=0)
     {
       /* clear tok_ptr for next strtok */
       tok_ptr = NULL;
 
       /* look for "." in the symbol */
       source = find_yahoo_source(symbol);
 
       switch (source)
-  {
-  case YAHOO_US:
-
-    if (us_quotes) 
-      {
-        lgr_us_quotes = strlen(us_quotes);
-        lgr_symbol = strlen(symbol);
-
-        us_quotes_temp = malloc(lgr_us_quotes + lgr_symbol +2);
-        if(us_quotes_temp==NULL)
-    {
-      fprintf(stderr,"Memory allocating error (%s line %d)\n"
-        ,__FILE__, __LINE__);
-      exit(1);  
-    }
-        strcpy(us_quotes_temp, us_quotes);
-        strcat(us_quotes_temp,"+");
-        strcat(us_quotes_temp,symbol);
-
-        free(us_quotes);
-        us_quotes = us_quotes_temp; 
-      }       
-    else 
-      {
-        us_quotes = malloc(strlen(symbol)+1);
-
-        if(us_quotes==NULL)
-    {
-      fprintf(stderr,"Memory allocating error (%s line %d)\n"
-        ,__FILE__, __LINE__);
-      exit(1);  
-    }
-        strcpy(us_quotes, symbol);
-      }
-
-    break;
-
-  case YAHOO_EUROPE:
-
-    if (eu_quotes) 
-      {
-        lgr_eu_quotes = strlen(eu_quotes);
-        lgr_symbol = strlen(symbol);
-        
-        eu_quotes_temp = malloc(lgr_eu_quotes + lgr_symbol +2);
-        if(eu_quotes_temp==NULL)
-    {
-      fprintf(stderr,"Memory allocating error (%s line %d)\n"
-        ,__FILE__, __LINE__);
-      exit(1);  
-    }
-        strcpy(eu_quotes_temp, eu_quotes);
-        strcat(eu_quotes_temp, "+");
-        strcat(eu_quotes_temp, symbol);
-
-        free(eu_quotes);
-        eu_quotes = eu_quotes_temp; 
-      }       
-    else 
-      {
-        eu_quotes = malloc(strlen(symbol)+1);
-        if(eu_quotes==NULL)
-    {
-      fprintf(stderr,"Memory allocating error (%s line %d)\n"
-        ,__FILE__, __LINE__);
-      exit(1);  
-    }
-        strcpy(eu_quotes, symbol);
-      }
-    break;
-  }
+        {
+          case YAHOO_US:
+            if (us_quotes)
+              {
+                lgr_us_quotes = strlen(us_quotes);
+                lgr_symbol = strlen(symbol);
+
+                us_quotes_temp = malloc(lgr_us_quotes + lgr_symbol +2);
+                if(us_quotes_temp==NULL)
+                  {
+                    fprintf(stderr,"Memory allocating error (%s line %d)\n",
+                            __FILE__, __LINE__);
+                    exit(1);
+                  }
+                strcpy(us_quotes_temp, us_quotes);
+                strcat(us_quotes_temp,"+");
+                strcat(us_quotes_temp,symbol);
+
+                free(us_quotes);
+                us_quotes = us_quotes_temp;
+              }
+            else
+              {
+                us_quotes = malloc(strlen(symbol)+1);
+
+                if(us_quotes==NULL)
+                  {
+                     fprintf(stderr,"Memory allocating error (%s line %d)\n",
+                             __FILE__, __LINE__);
+                     exit(1);
+                  }
+                strcpy(us_quotes, symbol);
+              }
+
+              break;
+
+          case YAHOO_EUROPE:
+            if (eu_quotes)
+              {
+                lgr_eu_quotes = strlen(eu_quotes);
+                lgr_symbol = strlen(symbol);
+
+                eu_quotes_temp = malloc(lgr_eu_quotes + lgr_symbol +2);
+                if(eu_quotes_temp==NULL)
+                  {
+                     fprintf(stderr,"Memory allocating error (%s line %d)\n",
+                             __FILE__, __LINE__);
+                     exit(1);
+                 }
+               strcpy(eu_quotes_temp, eu_quotes);
+               strcat(eu_quotes_temp, "+");
+               strcat(eu_quotes_temp, symbol);
+
+               free(eu_quotes);
+               eu_quotes = eu_quotes_temp;
+             }
+           else
+             {
+               eu_quotes = malloc(strlen(symbol)+1);
+               if(eu_quotes==NULL)
+                 {
+                   fprintf(stderr,"Memory allocating error (%s line %d)\n",
+                           __FILE__, __LINE__);
+                   exit(1);
+                 }
+               strcpy(eu_quotes, symbol);
+             }
+           break;
+        }
     }
 
   free(tok_ptr);
 
   if (us_quotes)
     {
       /* Gets us quotes */
       error = download_stocks(us_quotes, &stocks_tmp, YAHOO_US);
+      free(us_quotes);
       if (error) return error;
     }
- 
+
   if (eu_quotes)
     {
       /* Gets european quotes */
       error = download_stocks(eu_quotes, &stocks_getted, YAHOO_EUROPE);
+      free(eu_quotes);
       if (error) return error;
 
       /* concats lists if needed */
       if (stocks_tmp)
-  {
-    stocks_tmp2 = stocks_tmp;
+        {
+          stocks_tmp2 = stocks_tmp;
 
-    while(stocks_tmp2 != NULL) 
-      {
-        last_stock = stocks_tmp2;
-        stocks_tmp2 = next_stock(stocks_tmp2);
-      }
+          while(stocks_tmp2 != NULL)
+            {
+              last_stock = stocks_tmp2;
+              stocks_tmp2 = next_stock(stocks_tmp2);
+            }
 
-    last_stock->NextStock = stocks_getted;
-    stocks_getted->PreviousStock = last_stock;
+          last_stock->NextStock = stocks_getted;
+          stocks_getted->PreviousStock = last_stock;
 
-  }
-      else (stocks_tmp = stocks_getted);      
+        }
+      else
+          (stocks_tmp = stocks_getted);
     }
 
-  *stock_datas = stocks_tmp; 
-  
+  *stock_datas = stocks_tmp;
+
   return(0);
 }