int cmd_alter(int argc,const char **argv){
// check necessary param
check_cmd_args(argc,argv);
st_show_sql *stsql=(st_show_sql*)malloc(sizeof(st_show_sql));
char type[50];
char like[50];
const char *table="";
char sql[125];
while(*argv){
if(!strcmp(*argv,"--tables")){
stsql->type=*argv+2;
argv++;
}else if(!strcmp(*argv,"--columns")){
const char *t=*argv+2;
argv++;
if(!start_with(*argv,"--")){
usage("about show --columns table-name");
}
sprintf(type,"%s FROM %s%s",t,DBPRE,*argv);
stsql->type=type;
argv++;
}else if(!strcmp(*argv,"--create")){
const char *t=*argv+2;
argv++;
if(!start_with(*argv,"--")){
usage("about show --create table-name");
}
sprintf(type,"%s TABLE %s%s",t,DBPRE,*argv);
stsql->type=type;
argv++;
}else if(!strcmp(*argv,"--variables")){
stsql->type=*argv+2;
argv++;
}else if(!strcmp(*argv,"--like")){
argv++;
cat_sql_like(*argv,like);
argv++;
}else{
argv++;
}
}
stsql->table=table;
stsql->like=like;
parse_show_sql(stsql,sql);
MYSQL_RES *res=select(sql);
print_sql_result(res,1);
free_res(res);
return 0;
}
bool rsingle_diff_search_index::search(std::string &key, std::string &value, std::set<std::string> & search)
{
if (start_with(key, "rsingle_diff_0_ge") || start_with(key, "rsingle_diff_1_ge") || start_with(key, "rsingle_diff_2_ge"))
{
return do_check_rsingle_diff_ge(key, value, search);
}
else if (start_with(key, "rsingle_diff_0_le") || start_with(key, "rsingle_diff_1_le") || start_with(key, "rsingle_diff_2_le"))
{
return do_check_rsingle_diff_le(key, value, search);
}
return false;
}
// Central CELS function that provides all CELS services
int CELS_Call (TABI_ELEMENT* params)
{
TABI_MAP p(params); p.dump();
char *service = p._str("service");
// ==== AUTO-SERVICES =====================================
// Ignore zero mem parameter to Set* calls
if (start_with (service, "Set") && isupper(service[3]))
if (p._int("mem",1)==0)
return p._return(p._str("method"));
// Limit* = Set* if Get*>limit
if (start_with (service, "Limit") && isupper(service[5])) return p._return(p._str("method")); // to do: get & set
/*
{
char new_service[MAX_METHOD_STRLEN];
sprintf(new_service, "Get%s", service+5);
MemSize mem = TABI_callret(CELS_Call, TABI_DYNAMAP(p) ("service", new_service));
if (mem <= p._longlong("mem")) // if method already uses less memory than specified limit
return p._return(p._str("method")); // then return method unmodified
sprintf(new_service, "Set%s", service+5);
return TABI_call(CELS_Call, TABI_DYNAMAP(p) ("service", new_service));
}
*/
if (strequ (service, "encryption?")) return 1; // to do: aes-specific
if (start_with (p._str("method",""), "aes")) return p._return(p._str("method")); // to do: aes-specific
//default: GetBlockSize {return 0;}
//default: SetBlockSize {}
// ========================================================
// Find appropriate method to service this call
for (int i=0; i<methodsCount; i++)
{
try
{
int x = methodsTable[i](params);
if (x!=FREEARC_ERRCODE_NOT_IMPLEMENTED)
return x;
}
catch (...)
{
}
}
return FREEARC_ERRCODE_NOT_IMPLEMENTED;
}
static int has_cmd_args(const char **argv,const char *arg){
while(*argv){
if(!start_with(*argv,"--") && !strcmp(*argv+2,arg)){
return 1;
}
argv++;
}
return 0;
}
int main() {
//variables
struct sockaddr_in serverAddress, clientAddress;
char * ipClient;//pour l'affichage de l'adresse
int serverSocket, clientSocket, err;
socklen_t clientAddrLen = sizeof(clientAddress);
void * line;
choice_t * choix_joueur, choix_serveur;
score_t score;
win_t win;
end_t end;
//creation du socket
serverSocket = socket(AF_INET, SOCK_STREAM, 0);
if (serverSocket < 0) {
puts("Cannot open socket.");
exit(EXIT_FAILURE);
}
puts("Socket openned.");
//liaison au port
serverAddress.sin_family = AF_INET;
serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddress.sin_port = htons(SERVER_PORT);
err = bind(serverSocket, (struct sockaddr *) &serverAddress, sizeof(serverAddress));
if (err < 0) {
printf("Cannot bind port %hu.\n", SERVER_PORT);
close(serverSocket);
exit(EXIT_FAILURE);
}
printf("Port %hu bound.\n", SERVER_PORT);
//ecoute du port
err = listen(serverSocket, MAX_CLIENTS);
if (err < 0) {
printf("Cannot listen port %hu.\n", SERVER_PORT);
close(serverSocket);
exit(EXIT_FAILURE);
}
printf("Listening port %hu.\n", SERVER_PORT);
while (1) {
//attente de connection
clientSocket = accept(serverSocket, (struct sockaddr *) &clientAddress, &clientAddrLen);
if (clientSocket < 0) {
puts("Cannot accept connection.");
close(serverSocket);
exit(EXIT_FAILURE);
}
ipClient = inet_ntoa(clientAddress.sin_addr);
printf("New connection from %s.\n", ipClient);
//traitement
srand(time(NULL));
memcpy(choix_serveur.CHOICE, "CHOICE", 6);
choix_serveur.SPACE = ' ';
choix_serveur.ZERO = '\0';
memcpy(score.SCORE, "SCORE", 5);
score.SPACE = ' ';
score.ZERO = '\0';
score.player_score = 0;
score.server_score = 0;
memcpy(win.WIN, "WIN", 3);
win.SPACE = ' ';
win.ZERO = '\0';
memcpy(end.END, "END", 3);
end.SPACE = ' ';
end.ZERO = '\0';
line = read_line(clientSocket);
if (line == NULL || strcmp(line, "HELLO") != 0) {
puts("Communication error.");
close(clientSocket);
break;
}
free(line);
send(clientSocket, "OK", 3, 0);
line = read_line(clientSocket);
if (line == NULL || strcmp(line, "CHIFOUMI") != 0) {
puts("Communication error.");
close(clientSocket);
break;
}
free(line);
send(clientSocket, "OK", 3, 0);
while (1) {
line = read_line(clientSocket);
if (line == NULL || !start_with(line, "CHOICE")) {
break;
}
choix_joueur = line;
choix_serveur.choice = rand() % 3;
send(clientSocket, &choix_serveur, sizeof(choice_t), 0);
if (((choix_joueur->choice + 1) % 3) == choix_serveur.choice) {
win.winner = SERVER;
score.server_score++;
} else if (((choix_serveur.choice + 1) % 3) == choix_joueur->choice) {
win.winner = PLAYER;
score.player_score++;
} else {
win.winner = NONE;
}
free(line);
line = read_line(clientSocket);
if (line == NULL || strcmp(line, "OK") != 0) {
break;
}
free(line);
send(clientSocket, &win, sizeof(win_t), 0);
line = read_line(clientSocket);
if (line == NULL || strcmp(line, "OK") != 0) {
break;
}
free(line);
send(clientSocket, &score, sizeof(score_t), 0);
line = read_line(clientSocket);
if (line == NULL || strcmp(line, "OK") != 0) {
break;
}
free(line);
if (score.player_score == 3) {
end.winner = PLAYER;
} else if (score.server_score == 3) {
end.winner = SERVER;
} else {
end.winner = NONE;
}
send(clientSocket, &end, sizeof(end_t), 0);
line = read_line(clientSocket);
if (line == NULL || strcmp(line, "OK") != 0) {
break;
}
free(line);
}
//fermeture de la connection
while (read_line(clientSocket) != NULL);
printf("Connection with %s closed.\n", ipClient);
}
}
int main(int argc, char * argv[]) {
//variables
struct sockaddr_in clientAddress, serverAddress;
struct hostent * serverHost;
int clientSocket, err;
void * line;
choice_t * choix_serveur, choix_joueur;
score_t * score;
win_t * win;
end_t * end;
//arguments du programme
if (argc != 2) {
printf("%s <hostname>\n", argv[0]);
exit(EXIT_FAILURE);
}
//resolution de l'hôte
serverHost = gethostbyname(argv[1]);
if (serverHost == NULL) {
printf("Unknown host %s.\n", argv[1]);
exit(EXIT_FAILURE);
}
printf("Host %s found.\n", argv[1]);
serverAddress.sin_family = serverHost->h_addrtype;
memcpy(&serverAddress.sin_addr.s_addr, serverHost->h_addr_list[0], serverHost->h_length);
serverAddress.sin_port = htons(SERVER_PORT);
//creation du socket
clientSocket = socket(AF_INET, SOCK_STREAM, 0);
if (clientSocket < 0) {
puts("Cannot open socket");
exit(EXIT_FAILURE);
}
puts("Socket openned.");
//liaison a un port
clientAddress.sin_family = AF_INET;
clientAddress.sin_addr.s_addr = htonl(INADDR_ANY);
clientAddress.sin_port = htons(0);
err = bind(clientSocket, (struct sockaddr *) &clientAddress, sizeof(clientAddress));
if (err < 0) {
puts("Cannot bind port %hu.");
close(clientSocket);
exit(EXIT_FAILURE);
}
puts("Port bound.");
//connection au serveur
err = connect(clientSocket, (struct sockaddr *) &serverAddress, sizeof(serverAddress));
if (err < 0) {
printf("Cannot connect to server %s.\n", argv[1]);
close(clientSocket);
exit(EXIT_FAILURE);
}
printf("Connected to %s.\n", argv[1]);
//traitement
send(clientSocket, "HELLO", 6, 0);
line = read_line(clientSocket);
if (line == NULL || strcmp(line, "OK") != 0) {
puts("Communication error");
close(clientSocket);
exit(EXIT_FAILURE);
}
free(line);
send(clientSocket, "CHIFOUMI", 9, 0);
line = read_line(clientSocket);
if (line == NULL || strcmp(line, "OK") != 0) {
puts("Communication error");
close(clientSocket);
exit(EXIT_FAILURE);
}
free(line);
memcpy(choix_joueur.CHOICE, "CHOICE", 6);
choix_joueur.SPACE = ' ';
choix_joueur.ZERO = '\0';
while (1) {
printf("Entrez %hhu pour pierre, %hhu pour feuille et %hhu pour ciseau : ", PIERRE, FEUILLE, CISEAU);
scanf("%hhu", &choix_joueur.choice);
while (choix_joueur.choice > 2) {
puts("Invalide.");
printf("Entrez %hhu pour pierre, %hhu pour feuille et %hhu pour ciseau : ", PIERRE, FEUILLE, CISEAU);
scanf("%hhu", &choix_joueur.choice);
}
switch (choix_joueur.choice) {
case PIERRE:
puts("Vous avez choisi PIERRE.");
break;
case FEUILLE:
puts("Vous avez choisi FEUILLE.");
break;
case CISEAU:
puts("Vous avez choisi CISEAU.");
break;
}
send(clientSocket, &choix_joueur, sizeof(choice_t), 0);
line = read_line(clientSocket);
if (line == NULL || !start_with(line, "CHOICE")) {
puts("Communication error");
close(clientSocket);
exit(EXIT_FAILURE);
}
choix_serveur = line;
switch (choix_serveur->choice) {
case PIERRE:
puts("Le serveur a choisi PIERRE.");
break;
case FEUILLE:
puts("Le serveur a choisi FEUILLE.");
break;
case CISEAU:
puts("Le serveur a choisi CISEAU.");
break;
}
free(line);
send(clientSocket, "OK", 3, 0);
line = read_line(clientSocket);
if (line == NULL || !start_with(line, "WIN")) {
puts("Communication error");
close(clientSocket);
exit(EXIT_FAILURE);
}
send(clientSocket, "OK", 3, 0);
win = line;
switch (win->winner) {
case PLAYER:
puts("Vous l'emportez.");
break;
case SERVER:
puts("Le serveur l'emporte.");
break;
case NONE:
puts("Egalite.");
break;
}
free(line);
line = read_line(clientSocket);
if (line == NULL || !start_with(line, "SCORE")) {
puts("Communication error");
close(clientSocket);
exit(EXIT_FAILURE);
}
send(clientSocket, "OK", 3, 0);
score = line;
printf("Scores :\t\tVous %hhu\t\tLe serveur %hhu\n", score->player_score, score->server_score);
free(line);
line = read_line(clientSocket);
if (line == NULL || !start_with(line, "END")) {
puts("Communication error");
close(clientSocket);
exit(EXIT_FAILURE);
}
end = line;
send(clientSocket, "OK", 3, 0);
if (end->winner == PLAYER) {
puts("Vous avez gagne la partie.");
free(line);
break;
} else if (end->winner == SERVER) {
puts("Le serveur a gagne la partie.");
free(line);
break;
}
free(line);
}
//fin du programme
close(clientSocket);
puts("Connection closed.");
exit(EXIT_SUCCESS);
}
int main (int argc, char **argv)
{
// Optimize allocation for Tornado (2GB hash allocated after 1GB dictionary)
AllocTopDown = FALSE;
// Operation mode
OPMODE global_mode=AUTO;
// Record that stores all the info required for ReadWriteCallback
static Results r;
r.use_cpu_time = r.quiet_title = r.quiet_header = r.quiet_progress = r.quiet_result = FALSE;
// Default compression parameters are equivalent to option -5
r.method = std_Tornado_method [default_Tornado_method];
// Delete successfully (de)compressed input files
bool delete_input_files = FALSE;
// Count of files to process
int fcount=0;
// Output path/filename
const char *output_filename = NULL;
// Process options until "--"
// 1. First, process -1..-16 option if any
for (char **argv_ptr = argv; *++argv_ptr!=NULL; ) {
char *param = *argv_ptr;
if (*param == '-') {
param++;
if (strcasecmp(param,"-")==0) break; // "--" is a "stop processing" option
else if (isdigit(*param)) r.method = std_Tornado_method[check_parse_int (param, 1, elements(std_Tornado_method)-1, param-1)];
}
}
// 2. Second, process rest of options
for (char **argv_ptr = argv; *++argv_ptr!=NULL; ) {
char *param = *argv_ptr;
if (param[0] != '-' || param[1]=='\0') {
fcount++;
} else { param++; int error=0;
if (strcasecmp(param,"-")==0) break;
else if (strcasecmp(param,"") ==0) continue;
else if (strcasecmp(param,"z")==0) global_mode=_COMPRESS;
else if (strcasecmp(param,"d")==0) global_mode=_DECOMPRESS;
else if (strcasecmp(param,"delete")==0) delete_input_files=TRUE;
else if (strcasecmp(param,"t")==0) output_filename="";
else if (strcasecmp(param,"q")==0) r.quiet_title = r.quiet_header = r.quiet_progress = r.quiet_result = TRUE;
#ifndef FREEARC_NO_TIMING
else if (strcasecmp(param,"cpu")==0) r.use_cpu_time=TRUE;
#endif
else if (strcasecmp(param,"h")==0) global_mode=HELP;
else if (strcasecmp(param,"b")==0) r.method.buffer = MAX_BUFFER_SIZE; // set buffer size to the maximum supported by LZ coders
else if (strcasecmp(param,"x")==0) r.method.caching_finder = CACHING_MF4;
else if (strcasecmp(param,"xx")==0) r.method.caching_finder = CYCLED_MF4;
else if (strcasecmp(param,"x+")==0) r.method.caching_finder = CACHING_MF4;
else if (strcasecmp(param,"x-")==0) r.method.caching_finder = NON_CACHING_MF;
else if (strcasecmp(param,"t+")==0) r.method.find_tables = TRUE;
else if (strcasecmp(param,"t-")==0) r.method.find_tables = FALSE;
else if (strcasecmp(param,"t1")==0) r.method.find_tables = TRUE;
else if (strcasecmp(param,"t0")==0) r.method.find_tables = FALSE;
else if (strcasecmp(param,"s")==0) r.method.hash3 = 1;
else if (strcasecmp(param,"ss")==0) r.method.hash3 = 2;
else if (strcasecmp(param,"s+")==0) r.method.hash3 = 1;
else if (strcasecmp(param,"s-")==0) r.method.hash3 = 0;
else if (start_with(param,"fb")) r.method.fast_bytes = check_parse_int (param+2, MIN_FAST_BYTES, MAX_FAST_BYTES, *argv_ptr);
#ifdef FREEARC_WIN
else if (strcasecmp(param,"slp-")==0) DefaultLargePageMode = DISABLE;
else if (strcasecmp(param,"slp" )==0) DefaultLargePageMode = TRY;
else if (strcasecmp(param,"slp+")==0) DefaultLargePageMode = FORCE;
#endif
else if (start_with(param,"rem")) /* ignore option */;
else if (isdigit(*param)) ; // -1..-16 option is already processed :)
else switch( tolower(*param++) ) {
case 'b': r.method.buffer = check_parse_mem (param, MIN_BUFFER_SIZE, MAX_BUFFER_SIZE, *argv_ptr); break;
case 'h': r.method.hashsize = check_parse_mem (param, MIN_HASH_SIZE, MAX_HASH_SIZE, *argv_ptr); break;
case 'l': r.method.hash_row_width = check_parse_int (param, 1, MAX_HASH_ROW_WIDTH, *argv_ptr); break;
case 'u': r.method.update_step = check_parse_int (param, 1, MAX_UPDATE_STEP, *argv_ptr); break;
case 'c': r.method.encoding_method = check_parse_int (param, BYTECODER, ARICODER, *argv_ptr); break;
case 's': r.method.hash3 = check_parse_int (param, 0, 2, *argv_ptr); break;
case 'p': r.method.match_parser = parseInt (param, &error); break;
case 'x': r.method.caching_finder = parseInt (param, &error); break;
case 'o': output_filename = param; break;
case 'q':
#ifndef FREEARC_NO_TIMING
r.quiet_title = strchr (param, 't');
r.quiet_progress = strchr (param, 'p');
#endif
r.quiet_header = strchr (param, 'h');
r.quiet_result = strchr (param, 'r');
break;
case 'a': switch( tolower(*param++) ) {
case 'h': r.method.auxhash_size = check_parse_mem (param, MIN_HASH_SIZE, MAX_HASH_SIZE, *argv_ptr); goto check_for_errors;
case 'l': r.method.auxhash_row_width = check_parse_int (param, 1, MAX_HASH_ROW_WIDTH, *argv_ptr); goto check_for_errors;
}
// 'a' should be the last case!
default : fprintf (stderr, "ERROR: unknown option '%s'\n", *argv_ptr);
exit(FREEARC_EXIT_ERROR);
}
check_for_errors:
if (error) {
fprintf (stderr, "ERROR: bad option format: '%s'\n", *argv_ptr);
exit(FREEARC_EXIT_ERROR);
}
if (!(r.method.match_parser==GREEDY || r.method.match_parser==LAZY || r.method.match_parser==OPTIMAL)) {
fprintf (stderr, "ERROR: bad option value: '%s'\n", *argv_ptr);
exit(FREEARC_EXIT_ERROR);
}
int mf = r.method.caching_finder;
r.method.caching_finder = mf = (mf==CACHING_MF4_DUB? CACHING_MF4 : (mf==CYCLED_MF4_DUB? CYCLED_MF4 : mf));
if (!(mf==NON_CACHING_MF || (CYCLED_MF4<=mf && mf<=CYCLED_MF7) || (CACHING_MF4<=mf && mf<=CACHING_MF7) || (BT_MF4<=mf && mf<=BT_MF7))) {
fprintf (stderr, "ERROR: non-existing match finder: '%s'\n", *argv_ptr);
exit(FREEARC_EXIT_ERROR);
}
}
}
// No files to compress: read from stdin and write to stdout
if (global_mode!=HELP && fcount==0 &&
(global_mode!=AUTO || !isatty(0) && !isatty(1)) ) {
static char *_argv[] = {argv[0], (char*)"-", NULL};
argv = _argv;
fcount = 1;
} else if (global_mode==HELP || fcount==0) {
char h[100], ah[100], b[100], MinHashSizeStr[100], MaxHashSizeStr[100], MinBufSizeStr[100], MaxBufSizeStr[100];
showMem64 (r.method.hashsize, h);
showMem64 (r.method.auxhash_size, ah);
showMem64 (r.method.buffer, b);
showMem64 (MIN_HASH_SIZE, MinHashSizeStr);
showMem64 (MAX_HASH_SIZE+1, MaxHashSizeStr);
showMem64 (MIN_BUFFER_SIZE, MinBufSizeStr);
showMem64 (MAX_BUFFER_SIZE, MaxBufSizeStr);
printf( "Tornado compressor v0.6 (c) [email protected] http://freearc.org 2014-03-08\n"
"\n"
" Usage: tor [options and files in any order]\n"
" -# -- compression level (1..%d), default %d\n", int(elements(std_Tornado_method))-1, default_Tornado_method);
printf( " -z -- force compression\n"
" -d -- force decompression\n"
" -oNAME -- output filename/directory (default %s/%s)\n", COMPRESS_EXT, DECOMPRESS_EXT);
printf( " -t -- test (de)compression (redirect output to nul)\n"
" -delete -- delete successfully (de)compressed input files\n"
#ifdef FREEARC_NO_TIMING
" -q -- be quiet; -q[hr]* disables header/results individually\n"
#else
" -q -- be quiet; -q[thpr]* disables title/header/progress/results individually\n"
" -cpu -- compute raw CPU time (for benchmarking)\n"
#endif
#ifdef FREEARC_WIN
" -slp[+/-/] -- force/disable/try(default) large pages support (2mb/4mb)\n"
#endif
" -rem... -- command-line remark\n"
" -h -- display this help\n"
" -- -- stop flags processing\n"
" \"-\" used as filename means stdin/stdout\n"
"\n"
" Advanced compression parameters:\n"
" -b# -- buffer size (%s..%s), default %s\n", MinBufSizeStr, MaxBufSizeStr, b);
printf( " -h# -- hash size (%s..%s-1), default %s\n", MinHashSizeStr, MaxHashSizeStr, h);
printf( " -l# -- length of hash row (1..%d), default %d\n", int(MAX_HASH_ROW_WIDTH), r.method.hash_row_width);
printf( " -ah# -- auxiliary hash size (%s..%s-1), default %s\n", MinHashSizeStr, MaxHashSizeStr, ah);
printf( " -al# -- auxiliary hash row length (1..%d), default %d\n", int(MAX_HASH_ROW_WIDTH), r.method.auxhash_row_width);
printf( " -u# -- update step (1..%d), default %d\n", int(MAX_UPDATE_STEP), r.method.update_step);
printf( " -c# -- coder (1-bytes, 2-bits, 3-huf, 4-arith), default %d\n", r.method.encoding_method);
printf( " -p# -- parser (1-greedy, 2-lazy, 4-optimal), default %d\n", r.method.match_parser);
printf( " -x# -- match finder (0: non-caching ht4, 4-7: cycling cached ht4..ht7,\n"
" 14-17: shifting cached ht4..ht7, 24-27: bt4..bt7), default %d\n", r.method.caching_finder);
printf( " -s# -- 2/3-byte hash (0-disabled, 1-fast, 2-max), default %d\n", r.method.hash3);
printf( " -t# -- table diffing (0-disabled, 1-enabled), default %d\n", r.method.find_tables);
printf( " -fb# -- fast bytes in the optimal parser (%d..%d), default %d\n", int(MIN_FAST_BYTES), int(MAX_FAST_BYTES), r.method.fast_bytes);
printf( "\n"
" Predefined methods:\n");
for (int i=1; i<elements(std_Tornado_method); i++)
{
printf(" %-8d-- %s\n", -i, name(std_Tornado_method[i]));
}
exit(EXIT_SUCCESS);
}
// (De)compress all files given on cmdline
bool parse_options=TRUE; // options will be parsed until "--"
Install_signal_handler(signal_handler);
for (char **parameters = argv; *++parameters!=NULL; )
{
// If options are still parsed and this argument starts with "-" - it's an option
if (parse_options && parameters[0][0]=='-' && parameters[0][1]) {
if (strequ(*parameters,"--")) parse_options=FALSE;
continue;
}
// Save input filename
r.filename = *parameters;
// Select operation mode if it was not specified on cmdline
r.mode = global_mode != AUTO? global_mode :
end_with (r.filename, COMPRESS_EXT)? _DECOMPRESS :
_COMPRESS;
// Extension that should be added to output filenames
const char *MODE_EXT = r.mode==_COMPRESS? COMPRESS_EXT : DECOMPRESS_EXT;
// Construct output filename
if (r.mode==BENCHMARK || output_filename && strequ (output_filename, "")) { // Redirect output to nul
strcpy (r.outname, "");
} else if (output_filename) {
if (strequ(output_filename,"-"))
strcpy (r.outname, output_filename);
else if (is_path_char (last_char (output_filename)))
{sprintf(r.outname, "%s%s", output_filename, drop_dirname(r.filename)); goto add_remove_ext;}
else if (dir_exists (output_filename))
{sprintf(r.outname, "%s%c%s", output_filename, PATH_DELIMITER, drop_dirname(r.filename)); goto add_remove_ext;}
else
strcpy (r.outname, output_filename);
} else if (strequ(r.filename,"-")) {
strcpy (r.outname, r.filename);
} else {
// No output filename was given on cmdline:
// on compression - add COMPRESS_EXT
// on decompression - remove COMPRESS_EXT (and add DECOMPRESS_EXT if file already exists)
strcpy (r.outname, r.filename);
add_remove_ext: // Remove COMPRESS_EXT on the end of name or add DECOMPRESS_EXT (unless we are in _COMPRESS mode)
if (r.mode!=_COMPRESS && end_with (r.outname, COMPRESS_EXT)) {
r.outname [strlen(r.outname) - strlen(COMPRESS_EXT)] = '\0';
if (file_exists (r.outname))
strcat(r.outname, MODE_EXT);
} else {
strcat(r.outname, MODE_EXT);
}
}
// Open input file
r.fin = strequ (r.filename, "-")? stdin : file_open_read_binary(r.filename);
if (r.fin == NULL) {
fprintf (stderr, "\n Can't open %s for read\n", r.filename);
exit(FREEARC_EXIT_ERROR);
}
set_binary_mode (r.fin);
// Open output file
if (*r.outname) {
r.fout = strequ (r.outname, "-")? stdout : file_open_write_binary(r.outname);
if (r.fout == NULL) {
fprintf (stderr, "\n Can't open %s for write\n", r.outname);
exit(FREEARC_EXIT_ERROR);
}
set_binary_mode (r.fout);
} else {
r.fout = NULL;
}
// Prepare to (de)compression
int result; char filesize_str[100];
start_print_stats(r);
// Perform actual (de)compression
switch (r.mode) {
case _COMPRESS: {
if (!r.quiet_header && r.filesize >= 0)
fprintf (stderr, "Compressing %s bytes with %s\n", show3(r.filesize,filesize_str), name(r.method));
PackMethod m = r.method;
if (r.filesize >= 0)
m.buffer = mymin (m.buffer, r.filesize+LOOKAHEAD*2);
result = tor_compress (m, ReadWriteCallback, &r, NULL, -1);
break; }
case _DECOMPRESS: {
//if (!r.quiet_header && !strequ (r.outname, "-")) fprintf (stderr, "Unpacking %.3lf mb\n", double(r.filesize)/1000/1000);
result = tor_decompress (ReadWriteCallback, &r, NULL, -1);
break; }
}
// Finish (de)compression
print_final_stats(r);
fclose (r.fin);
if (r.fout) fclose (r.fout);
if (result == FREEARC_OK) {
if (delete_input_files && !strequ(r.filename,"-")) delete_file(r.filename);
} else {
if (!strequ(r.outname,"-") && !strequ(r.outname,"")) delete_file(r.outname);
switch (result) {
case FREEARC_ERRCODE_INVALID_COMPRESSOR:
fprintf (stderr, "\nThis compression mode isn't supported by small Tornado version, use full version instead!");
break;
case FREEARC_ERRCODE_NOT_ENOUGH_MEMORY:
fprintf (stderr, "\nNot enough memory for (de)compression!");
break;
case FREEARC_ERRCODE_READ:
fprintf (stderr, "\nRead error! Bad media?");
break;
case FREEARC_ERRCODE_WRITE:
fprintf (stderr, "\nWrite error! Disk full?");
break;
case FREEARC_ERRCODE_BAD_COMPRESSED_DATA:
fprintf (stderr, "\nData can't be decompressed!");
break;
default:
fprintf (stderr, "\n(De)compression failed with error code %d!", result);
break;
}
exit(FREEARC_EXIT_ERROR);
}
// going to next file...
}
return EXIT_SUCCESS;
}
int cmd_select(int argc,const char **argv){
// check necessary param
check_cmd_args(argc,argv);
st_select_sql *stsql=(st_select_sql*)malloc(sizeof(st_select_sql));
stsql->select="*";
stsql->limit=" LIMIT 20";
char *from="";
char where[256]={""};
char order[128]={""};
char limit[16]={""};
char group[64]={""};
int has_limit=has_cmd_args(argv,"limit");
while(*argv){
if(!strcmp(*argv,"--table") || !strcmp(*argv,"-t")){
argv++;
from=(char*)*argv;
argv++;
}else if(!strcmp(*argv,"--select")){
argv++;
stsql->select=*argv;
argv++;
}else if(!strcmp(*argv,"--limit")){
argv++;
stsql->limit=cat_sql_limit(*argv,limit);
argv++;
}else if(!strcmp(*argv,"--order")){
argv++;
const char *field=*argv;
argv++;
if(*argv==NULL){
cat_sql_sort(field,"ASC",order);
}else{
if(start_with(*argv,"--")){
cat_sql_sort(field,*argv,order);
}else{
cat_sql_sort(field,"ASC",order);
}
}
}else if(!strcmp(*argv,"--group")){
argv++;
stsql->group=cat_sql_group(*argv,"",group);
argv++;
if(has_limit==0){
stsql->limit="";
}
}else if(!start_with(*argv,"--")){
const char *name=*argv+2;
if(!strcmp(name,"id"))
name=get_primary_key(from);
argv++;
const char *value=*argv;
cat_sql_where(name,value,where);
argv++;
}else{
argv++;
}
}
stsql->from=from;
stsql->where=where;
stsql->order=order;
stsql->group=group;
char sql[512];
parse_select_sql(stsql,sql);
MYSQL_RES *res=select(sql);
print_sql_result(res,1);
free_res(res);
return 0;
}
io_http_res* http_get(const char* url, int timeout) {
io_http_req req;
io_http_res* res = malloc(sizeof(io_http_res));
parse_url(url, &req);
printf("http.host = %s, http.port = %d, http.path = %s, http.query = %s\n",
req.host, req.port, req.path, req.query_string);
int sockfd = io_tcp_connect(req.host, req.port);
if (sockfd < 0) return NULL;
// request buff
char buf[MAX_IO_BUFFER];
// poll
struct pollfd pfds[1];
int maxpfds = 1, nready = 0, n;
pfds[0].fd = sockfd;
pfds[0].events = POLLWRNORM;
for (;;) {
bzero(buf, sizeof(buf));
nready = poll(pfds, maxpfds, timeout);
if (nready < 0) {
fprintf(stderr, "%s:%d http poll error\n", __FILE__, __LINE__);
close(sockfd);
return NULL;
} else if (nready == 0) {
fprintf(stderr, "%s:%d http poll timeout\n", __FILE__, __LINE__);
close(sockfd);
return NULL;
}
if (pfds[0].revents & POLLWRNORM) {
// write
// printf("sizeof char[] = %ld\n", sizeof(buf));
if (req.query_string[0] == '\0')
snprintf(buf, sizeof(buf), "GET %s HTTP/1.1\r\n", req.path);
else
snprintf(buf, sizeof(buf), "GET %s?%s HTTP/1.1\r\n", req.path, req.query_string);
snprintf(buf + strlen(buf), sizeof(buf), "host: %s\r\n\r\n", req.host);
printf("request:\n%s\n", buf);
if (io_writen(sockfd, buf, strlen(buf)) < 0) {
fprintf(stderr, "%s:%d http send request error: %s\n", __FILE__, __LINE__, buf);
close(sockfd);
return NULL;
}
pfds[0].events = POLLRDNORM;
}
if (pfds[0].revents & POLLRDNORM) {
// read
if (io_readline(sockfd, buf, sizeof(buf)) < 0) {
fprintf(stdout, "%s:%d http recv message error\n", __FILE__, __LINE__);
close(sockfd);
return NULL;
}
printf("response status line:\n%s\n", buf);
sscanf(buf, "%s %d %s", res->version, &res->status_code, res->status_message);
// io_readn(sockfd, buf, 1024);
// printf("%s\n", buf);
if (res->status_code == 200) {
res->content_length = 0;
while (buf[0] != '\r' && buf[1] != '\n') {
io_readline(sockfd, buf, sizeof(buf));
fprintf(stdout, "%s\n", buf);
// Content-Length
if (14 == start_with(buf, "Content-Length")) {
res->content_length = atoi(buf + 15);
res->content = malloc(res->content_length);
}
}
if (res->content_length <= 0) {
res->content_length = 8192;
res->content = malloc(res->content_length);
}
n = io_readn(sockfd, res->content, res->content_length);
res->content[n] = '\0';
close(sockfd);
return res;
}
break;
}
}
close(sockfd);
return NULL;
}
