Google
Web alhem.net
Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

forms.cpp File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mysql/mysql.h>
#include <unistd.h>
#include <libmysqlwrapped.h>
#include <libfd.h>
#include <string>
#include <libcgi++.h>
#include <Utility.h>
#include <MinderHandler.h>
#include <openssl/sha.h>
#include "dbd.h"
#include "forms.h"

Include dependency graph for forms.cpp:

Include dependency graph

Go to the source code of this file.

Defines

#define D2(x)

Functions

void form_input (Database &db, Query &q, char *sql, Form *form, Cookies *cs, int &flik)

Define Documentation

#define D2 (  x   ) 
 

Value:

{ \
  FILE *fil = fopen("c:\\deb.log","at"); \
  x; \
  fclose(fil); \
}

Definition at line 42 of file forms.cpp.

Referenced by MySocketsLog::error(), MyErrlog::error(), form_input(), MenuHandler::get_next_id(), MyApp::Init(), MyDlgProc(), MenuHandler::OnCommand(), MyMinionSocket::OnVerifiedLine(), and MenuHandler::Valid().

Function Documentation

void form_input (  Database &  db,
Query &  q,
char *  sql,
Form *  form,
Cookies *  cs,
int &  flik
) 
 

Definition at line 49 of file forms.cpp.

References db::Item::category, D2, db::Item::data, g_bSize, g_pSocket, db::Linkitemtag::item, db::Category::name, db::Item::name, db::Tag::name, db::Category::num, db::Item::num, db::Tag::num, db::Category::save(), db::Item::save(), db::Tag::save(), db::Linkitemtag::save(), db::Item::sha1, db::Item::sz, db::Linkitemtag::tag, and db::Item::typ.

Referenced by run(). 

00050 {
00051         char slask[1000];
00052         if (form -> getvalue("post_form",slask,20) && *slask && atoi(slask))
00053         {
00054                 std::string typ = form -> getvalue("typ"); // 'File' / 'URL'
00055     D2(fprintf(fil," * post form type '%s'\n", typ.c_str());)
00056                 if (typ != "File" && typ != "URL" && typ != "Again")
00057                 {
00058                         return;
00059                 }
00060                 long category = 0;
00061                 if (form -> getvalue("newcategory",slask,1000) && *slask)
00062                 {
00063                         sprintf(sql,"select * from category where name='%s'", q.safestr(slask).c_str());
00064                         db::Category cat(&db,sql);
00065                         cat.name = slask;
00066                         cat.save();
00067                         category = cat.num;
00068                 }
00069                 else
00070                 {
00071                         form -> getvalue("category",slask,20);
00072                         category = atol(slask);
00073                         db::Category cat(db, category);
00074                         category = cat.num;
00075                 }
00076                 if (!category)
00077                 {
00078                         return;
00079                 }
00080                 long itemnum = 0;
00081                 // the_file, the_url
00082                 // tagx, newtagx
00083     if (typ == "Again")
00084     {
00085       form -> getvalue("itemnr",slask,20);
00086       long itemnr = atol(slask);
00087       db::Item item(db, itemnr);
00088       item.category = category;
00089       item.save();
00090       itemnum = item.num;
00091     }
00092     else
00093                 if (typ == "File")
00094                 {
00095                         std::string the_file = form -> getvalue("the_file");
00096                         FILE *fil = fopen(the_file.c_str(), "rb"); // hurrv, safety?
00097                         if (fil)
00098                         {
00099         size_t sz = 0;
00100         unsigned char sha1buf[20];
00101         {
00102           SHA_CTX ctx;
00103           SHA1_Init(&ctx);
00104           size_t n = fread(slask, 1, 1000, fil);
00105           while (n > 0)
00106           {
00107             SHA1_Update(&ctx, slask, n);
00108             sz += n;
00109             //
00110             n = fread(slask, 1, 1000, fil);
00111           }
00112           SHA1_Final(sha1buf, &ctx);
00113         }
00114                                 fclose(fil);
00115         if (sz >= 400000L)
00116         {
00117           g_bSize = true;
00118           return;
00119         }
00120         *slask = 0;
00121         for (int n = 0; n < 20; n++)
00122         {
00123           sprintf(slask + strlen(slask),"%02x",sha1buf[n]);
00124         }
00125         D2(fprintf(fil, " * file sha1: %s\n", slask);)
00126                                 db::Item item(db, sz, slask);
00127                                 cgi::Base64 b('@');
00128                                 item.typ = typ;
00129                                 item.category = category;
00130         size_t x = 0;
00131         for (size_t i = 0; i < the_file.size(); i++)
00132         {
00133           if (the_file[i] == '\\')
00134           {
00135             x = i + 1;
00136           }
00137         }
00138                                 item.name = the_file.substr(x);
00139         D2(fprintf(fil, " * encoding base64\n");)
00140                                 b.encode_from_file(the_file.c_str(), item.data);
00141         item.sz = sz;
00142         item.sha1 = slask;
00143                                 item.save();
00144                                 itemnum = item.num;
00145         D2(fprintf(fil, " * new item saved\n");)
00146                         }
00147                 }
00148                 else // typ == "URL"
00149                 {
00150                         std::string the_url = form -> getvalue("the_url");
00151                         if (the_url.size() > 7 && !strncasecmp(the_url.c_str(), "http://", 7))
00152                         {
00153         size_t sz = the_url.size();
00154         unsigned char sha1buf[20];
00155         {
00156           SHA_CTX ctx;
00157           SHA1_Init(&ctx);
00158           SHA1_Update(&ctx, the_url.c_str(), the_url.size());
00159           SHA1_Final(sha1buf, &ctx);
00160         }
00161         *slask = 0;
00162         for (int n = 0; n < 20; n++)
00163         {
00164           sprintf(slask + strlen(slask),"%02x",sha1buf[n]);
00165         }
00166                                 db::Item item(db, sz, slask);
00167                                 item.typ = typ;
00168                                 item.category = category;
00169                                 item.name = the_url;
00170         item.sz = sz;
00171         item.sha1 = slask;
00172                                 item.save();
00173                                 itemnum = item.num;
00174                         }
00175                 }
00176                 if (!itemnum)
00177                 {
00178                         return;
00179                 }
00180     long tag1 = 0;
00181     long tag2 = 0;
00182     long tag3 = 0;
00183     // tag 1
00184     if (form -> getvalue("newtag1",slask,1000) && *slask)
00185     {
00186       sprintf(sql,"select * from tag where name='%s'", q.safestr(slask).c_str());
00187       db::Tag tag(&db, sql);
00188       tag.name = slask;
00189       tag.save();
00190       db::Linkitemtag x(db, itemnum, tag.num);
00191       x.item = itemnum;
00192       x.tag = tag.num;
00193       x.save();
00194       tag1 = tag.num;
00195     }
00196     else
00197     {
00198       form -> getvalue("tag1",slask,20);
00199       long tagnum = atol(slask);
00200       db::Tag tag(db, tagnum);
00201       tagnum = tag.num;
00202       if (tagnum)
00203       {
00204         db::Linkitemtag x(db, itemnum, tagnum);
00205         x.item = itemnum;
00206         x.tag = tagnum;
00207         x.save();
00208         tag1 = tagnum;
00209       }
00210     }
00211     // tag 2
00212     if (form -> getvalue("newtag2",slask,1000) && *slask)
00213     {
00214       sprintf(sql,"select * from tag where name='%s'", q.safestr(slask).c_str());
00215       db::Tag tag(&db, sql);
00216       tag.name = slask;
00217       tag.save();
00218       db::Linkitemtag x(db, itemnum, tag.num);
00219       x.item = itemnum;
00220       x.tag = tag.num;
00221       x.save();
00222       tag2 = tag.num;
00223     }
00224     else
00225     {
00226       form -> getvalue("tag2",slask,20);
00227       long tagnum = atol(slask);
00228       db::Tag tag(db, tagnum);
00229       tagnum = tag.num;
00230       if (tagnum)
00231       {
00232         db::Linkitemtag x(db, itemnum, tagnum);
00233         x.item = itemnum;
00234         x.tag = tagnum;
00235         x.save();
00236         tag2 = tagnum;
00237       }
00238     }
00239     // tag 3
00240     if (form -> getvalue("newtag3",slask,1000) && *slask)
00241     {
00242       sprintf(sql,"select * from tag where name='%s'", q.safestr(slask).c_str());
00243       db::Tag tag(&db, sql);
00244       tag.name = slask;
00245       tag.save();
00246       db::Linkitemtag x(db, itemnum, tag.num);
00247       x.item = itemnum;
00248       x.tag = tag.num;
00249       x.save();
00250       tag3 = tag.num;
00251     }
00252     else
00253     {
00254       form -> getvalue("tag3",slask,20);
00255       long tagnum = atol(slask);
00256       db::Tag tag(db, tagnum);
00257       tagnum = tag.num;
00258       if (tagnum)
00259       {
00260         db::Linkitemtag x(db, itemnum, tagnum);
00261         x.item = itemnum;
00262         x.tag = tagnum;
00263         x.save();
00264         tag3 = tagnum;
00265       }
00266     }
00267     // send message
00268     //  'post' _ typ : 64(category) : 64(tag) : 64(tag) : 64(tag) : 64(name) : data(64) : sz : sha1
00269     {
00270 /*
00271   std::string msg = "Tip_" + Utility::l2string(GetHostId());
00272   SendMessage(Utility::base64(msg));
00273 */
00274       db::Item item(db, itemnum);
00275       db::Category cat(db, item.category);
00276 /*
00277       db::Tag t1(db, tag1);
00278       db::Tag t2(db, tag2);
00279       db::Tag t3(db, tag3);
00280 */
00281       std::string msg = "post_" + item.typ.String();
00282       msg += ":" + Utility::base64(cat.name);
00283 /*
00284       msg += ":" + Utility::base64(t1.num ? t1.name : " null");
00285       msg += ":" + Utility::base64(t2.num ? t2.name : " null");
00286       msg += ":" + Utility::base64(t3.num ? t3.name : " null");
00287 */
00288       msg += ":" + Utility::base64(item.name);
00289       msg += ":";
00290       for (std::vector<std::string>::iterator it = item.data.begin(); it != item.data.end(); it++)
00291       {
00292         msg += *it;
00293       }
00294       msg += ":" + Utility::l2string(item.sz);
00295       msg += ":" + item.sha1;
00296       sprintf(sql,"select * from linkitemtag where item=%ld", item.num);
00297       q.get_result(sql);
00298       while (q.fetch_row())
00299       {
00300         db::Linkitemtag x(&db,&q);
00301         db::Tag tag(db, x.tag);
00302         msg += ":" + Utility::base64(tag.name);
00303       }
00304       q.free_result();
00305 
00306       D2(fprintf(fil,"Sending message: %s\n", msg.c_str());)
00307 
00308       static_cast<MinderHandler&>(g_pSocket->Handler()).SendMessage(Utility::base64(msg));
00309     }
00310     flik = 1; // search
00311         }
00312 }

Generated on Thu Feb 10 22:42:35 2005 for Distributed URL Classification Tool by doxygen 1.3.7