int cChannelMap::read_config_file (string mapfile) { ifstream cmfile; string s; size_t p; int tvmid; int n; cmfile.open (mapfile.c_str()); if (!cmfile) { fprintf(stderr,"Unable to open channelmap file: %s.\n", mapfile.c_str()); return -1; } fprintf(stderr,"Load '%s': ", mapfile.c_str()); n = 0; while (!cmfile.eof ()) { getline (cmfile, s); if (!s.empty ()) { remove_whitespaces ((char *) s.c_str ()); // remove comments p = s.find_first_of ("//"); if (p != string::npos) s.erase (p); // split line p = s.find_first_of ("="); if ((p != string::npos) && (s.substr (p + 1).length ())) { char *ptr = NULL; tvmid = atoi (s.substr (0, p).c_str ()); if ((ptr = strdup(s.substr (p + 1).c_str ())) != NULL) { char *vpsptr = NULL; // one of the chars "1yYjJ" separated from the channelids // by a colon means the sender has VPS vpsmap[tvmid] = false; if ((vpsptr = index(ptr, ':')) != NULL) { *vpsptr++ = '\0'; vpsmap[tvmid] = (index("1yYjJ", *vpsptr) != NULL); } chanmap[tvmid].push_back(ptr); // are there more channelids separated by commas? while ((ptr = index(ptr, ',')) != NULL) { *ptr++ = '\0'; chanmap[tvmid].push_back(ptr); } } n++; } } } cmfile.close (); fprintf(stderr,"%d channel mappings read.\n", n); return n; }
keylist * parse_config ( char * buf ){ remove_remarks ( buf ); remove_whitespaces ( buf ); return parse_config_buf ( buf ); }
/** * Assumed that the right image is bound to IL */ int perform_operation(const char * operation, int verbose) { /* Where to store the first parsing results? */ char function[long_strlen], params[long_strlen], solid_params[long_strlen]; /* Get the function name string and parameters string */ parse_function(operation, function, params); /* Get rid of any whitespaces from the parameters string */ remove_whitespaces(params, solid_params); if (verbose) printf("Calling %s(%s)\n", function, solid_params); /* What function was wanted? -1 means that we don't know */ int function_index = -1; int i; for (i = 0; i < ILU_FUN_COUNT; i++) if (strncmp(function, ilu_functions[i].Name, short_strlen) == 0) {/* Yeah, this function was wanted. Let's have its index from the ilu_functions array */ function_index = i; break; /* nothing to do here any more */ } if (function_index == -1) {/* Seems we haven't found anything... */ fprintf(stderr, "Error: You have specified an invalid function name '%s' (have you called %s).\nRun '%s --help' command to get some help\n", function, operation, program_name); return 1; } /* We are going to try something and we want to know how it ended */ ILboolean return_value; switch (ilu_functions[function_index].Parameter_type) {/* First semi-automatic processing according to type of parameters */ case PARAM_VOID: { ILboolean (* function)() = ilu_functions[function_index].Callback; return_value = function(); break; }/* endcase PARAM_VOID */ case PARAM_ILUINT: { /* first assign and determine the type of the Callback */ ILboolean (* function)(ILuint) = ilu_functions[function_index].Callback; /* then declare the parameter variables */ ILuint param_value; /* fill them */ int success = sscanf(solid_params, "%u", & param_value); if (success != 1) {/* see how it ended */ fprintf(stderr, "Error interpreting '%s' as unsigned integer (when calling %s)\n", solid_params, operation); break; } /* execute the command and store the result */ return_value = function(param_value); break; }/* endcase PARAM_ILUINT */ case PARAM_ILFLOAT: { ILboolean (* function)(ILfloat) = ilu_functions[function_index].Callback; double param_value; int success = sscanf(solid_params, "%lf", & param_value); if (success != 1) { fprintf(stderr, "Error interpreting '%s' as float (when calling %s)\n", solid_params, operation); break; } return_value = function((ILfloat)param_value); break; }/* endcase PARAM_ILFLOAT */ case PARAM_OTHERS: switch (function_index) {/* next, the manual processing according to names */ case ILU_SHARPEN: { ILboolean (* function)(ILfloat, ILuint) = ilu_functions[function_index].Callback; double factor; ILuint iter; int success = sscanf(solid_params, "%lf,%u", & factor, & iter); if (success != 2) { fprintf(stderr, "Error interpreting '%s' as floating-point number and unsigned integer separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function((ILfloat)factor, iter); break; }/* endcase ILU_SHARPEN */ case ILU_CROP: { ILboolean (* function)(ILuint, ILuint, ILuint, ILuint, ILuint, ILuint ) = ilu_functions[function_index].Callback; ILuint xoff, yoff, zoff, width, height, depth; int success = sscanf(solid_params, "%u,%u,%u,%u,%u,%u", & xoff, & yoff, & zoff, & width, & height, & depth); if (success != 6) { fprintf(stderr, "Error interpreting '%s' as 6 unsigned integers separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function(xoff, yoff, zoff, width, height, depth); break; }/* endcase ILU_CROP */ case ILU_ENLARGECANVAS: case ILU_SCALE: { ILboolean (* function)(ILuint, ILuint, ILuint) = ilu_functions[function_index].Callback; ILuint width, height, depth; int success = sscanf(solid_params, "%u,%u,%u", & width, & height, & depth); if (success != 3) { fprintf(stderr, "Error interpreting '%s' as 3 unsigned integers separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function(width, height, depth); break; }/* endcase ILU_ENLARGECANVAS + ILU_SCALE */ case ILU_ENLARGEIMAGE: case ILU_SCALECOLOURS: { ILboolean (* function)(ILfloat, ILfloat, ILfloat) = ilu_functions[function_index].Callback; double first, second, third; int success = sscanf(solid_params, "%lf,%lf,%lf", & first, & second, & third); if (success != 3) { fprintf(stderr, "Error interpreting '%s' as 3 floating-point numbers separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function((ILfloat)first, (ILfloat)second, (ILfloat)third); break; }/* endcase ILU_ENLARGEIMAGE + ILU_SCALECOLOURS */ case ILU_ROTATE3D: case ILU_SATURATE4F: { ILboolean (* function)(ILfloat, ILfloat, ILfloat, ILfloat) = ilu_functions[function_index].Callback; double first, second, third, fourth; int success = sscanf(solid_params, "%lf,%lf,%lf,%lf", & first, & second, & third, & fourth); if (success != 4) { fprintf(stderr, "Error interpreting '%s' as 4 floating-point numbers separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function((ILfloat)first, (ILfloat)second, (ILfloat)third, (ILfloat)fourth); break; }/* endcase ILU_ROTATE3D + ILU_SATURATE4F */ case ILU_REPLACECOLOUR: { ILboolean (* function)(ILubyte, ILubyte, ILubyte, ILfloat ) = ilu_functions[function_index].Callback; ILuint red, green, blue; double tolerance; int success = sscanf(solid_params, "%u,%u,%u,%lf", & red, & green, & blue, & tolerance); if (success != 4) { fprintf(stderr, "Error interpreting '%s' as 3 8-bit unsigned integers and one floating-point number separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function((ILubyte)red, (ILubyte)green, (ILubyte)blue, (ILfloat)tolerance); break; }/* endcase ILU_ROTATE3D + ILU_SATURATE4F * */ /* iluConvolution(ILint *matrix, ILint scale, ILint bias); Any idea about this? */ }/* endswitch(function_index) */ break; }/* endswitch (ilu_functions[function_index].Parameter_type) */ /* It didn't end good for some reason... */ if (return_value == IL_FALSE) { int error= ilGetError(); fprintf(stderr, "Something got wrong when calling %s(%s): %s\n", function, solid_params, iluErrorString(error) ); return error; } return 0; }
int main(){ FILE *arq; char *result; int i,j; int size_key = 8; char msg[] = "Uma criança nasce sem qualquer conhecimento, sem qualquer consciência de seu próprio eu. E quando uma criança nasce, a primeira coisa da qual ela se torna consciente não é ela mesma; a primeira coisa da qual ela se torna consciente é o outro. Isso é natural, porque os olhos se abrem para fora, as mãos tocam os outros, os ouvidos escutam os outros, a língua saboreia a comida e o nariz cheira o exterior. Todos esses sentidos abrem-se para fora. O nascimento é isso. Nascimento significa vir a esse mundo: o mundo exterior. Assim, quando uma criança nasce, ela nasce nesse mundo. Ela abre os olhos e vê os outros. O outro significa o tu. Ela primeiro se torna consciente da mãe. Então, pouco a pouco, ela se torna consciente de seu próprio corpo. Esse também é o 'outro', também pertence ao mundo. Ela está com fome e passa a sentir o corpo; quando sua necessidade é satisfeita, ela esquece o corpo. É dessa maneira que a criança cresce. Primeiro ela se torna consciente do você, do tu, do outro, e então, pouco a pouco, contrastando com você, com tu, ela se torna consciente de si mesma. Essa consciência é uma consciência refletida. Ela não está consciente de quem ela é. Ela está simplesmente consciente da mãe e do que ela pensa a seu respeito. Se a mãe sorri, se a mãe aprecia a criança, se diz 'você é bonita', se ela a abraça e a beija, a criança sente-se bem a respeito de si mesma. Assim, um ego começa a nascer. Através da apreciação, do amor, do cuidado, ela sente que é ela boa, ela sente que tem valor, ela sente que tem importância. Um centro está nascendo. Mas esse centro é um centro refletido. Ele não é o ser verdadeiro. A criança não sabe quem ela é; ela simplesmente sabe o que os outros pensa a seu respeito. E esse é o ego: o reflexo, aquilo que os outros pensam. Se ninguém pensa que ela tem alguma utilidade, se ninguém a aprecia, se ninguém lhe sorri, então, também, um ego nasce - um ego doente, triste, rejeitado, como uma ferida, sentindo-se inferior, sem valor. Isso também é ego. Isso também é um reflexo."; int msg_lenght = (int) strlen (msg); Key *key; Cypher *original; Cypher *encripted; Cypher *desencripted; Cypher *breaked; key = (Key *)calloc(1,sizeof(Key)); key->msg = (char *)calloc(size_key,sizeof(char)); key->index = (int *)calloc(size_key,sizeof(int)); original = (Cypher *)calloc(1,sizeof(Cypher)); original->msg = (char *)calloc(msg_lenght,sizeof(char)); original->lenght = msg_lenght; encripted = (Cypher *)calloc(1,sizeof(Cypher)); encripted->msg = (char *)calloc(msg_lenght,sizeof(char)); encripted->lenght = msg_lenght; desencripted = (Cypher *)calloc(1,sizeof(Cypher)); desencripted->msg = (char *)calloc(msg_lenght,sizeof(char)); desencripted->lenght = msg_lenght; breaked = (Cypher *)calloc(1,sizeof(Cypher)); breaked->msg = (char *)calloc(msg_lenght,sizeof(char)); breaked->lenght = msg_lenght; strcpy(original->msg, msg); arq = fopen("key.txt", "rt"); if(arq == NULL) printf("Erro, nao foi possivel abrir o arquivo\n"); while (!feof(arq)){ result = fgets(key->msg, 100, arq); if (result) printf("key: %s", key->msg); i++; } key->lenght = (int) strlen(key->msg); //Pegando o vetor de index get_indexKey(key); //Tirando os espaços em branco remove_whitespaces(original); original->lenght = (int) strlen(original->msg); //Preenchendo os espaços restantes fill_spaces(original); original->lenght = (int) strlen(original->msg); //Cifrando o texto cipher(key, original, encripted); encripted->lenght = (int) strlen(encripted->msg); //Decifrando o texto decipher(key, encripted, desencripted); for(j = 0; j < size_key;j++){ printf("%d", key->index[j]); } printf("\nNormal: %s\n", original->msg); printf("\n\n"); printf("Ciphed: %s\n", encripted->msg); printf("\n\n"); printf("Deciphed: %s\n", desencripted->msg); printf("\n\n"); /* int key_break_size = 0; for (int i = 1; i <= 8; i++){ key_break_size = i; permutations(K_SIZE, text); }*/ //cypher(key, original, encripted); free(key); free(original); free(encripted); free(desencripted); return 0; }