int list_recursive(t_dlist *list, t_dlist *first, char ***pointed_square, int size, int tmp_lin, int tmp_col) { int result; int lin; int col; char **square; square = *pointed_square; (void)first; lin = 0; col = 0; result = (is_right(&square, &lin, &col, size, list)); print_it(list->content); ft_putnbr(result); /*if (result == 1 && list-> next != NULL) { tmp_lin = lin; tmp_col = col; list = list -> next; list_recursive (list, first, square, size, tmp_lin, tmp_col); }*/ ft_putstr("salut"); if (result == 0 && list->prev != NULL) { list = list -> prev; malloc_square(size); ft_putchar('M'); result = is_right (&square, &tmp_lin +1, &tmp_col + 1, size, list); print_it(list->content); ft_putnbr(result); } if (result == 1 && list-> next != NULL) { ft_putstr("post_M"); tmp_lin = lin; tmp_col = col; list = list -> next; list_recursive (list, first, &square, size, tmp_lin, tmp_col); } if (result == 0 && list->prev == NULL) { ft_putstr("yolo"); return (0); } if (result == 1 && list->next == NULL) { ft_putnbr(8); return (1); } return (0); }
unsigned int organize_and_print(t_struct_arg *args, const char *str, unsigned int i, unsigned chars_to_save) { t_params *params; t_tmp_arg *tmp; unsigned int chars_written; params = (t_params*)malloc(sizeof(*params)); tmp = (t_tmp_arg*)malloc(sizeof(*tmp)); if (params == NULL || tmp == NULL) return (i); init_params_to_zero(params); if (is_parameter_number(str + i)) i = find_good_param(params, &(args->arg_tmp), str, i); i = init_flags_width_prec(params, str, i + 1); i = init_length(params, str, i); if (params->is_width_in_arg == 1) params->width = va_arg(args->arg, int); if (params->is_precision_in_arg == 1) params->precision = va_arg(args->arg, int); if (params->is_other_param == 1) stock_arg(&(args->arg_tmp), tmp, str[i]); else if (params->is_other_param == 0) stock_arg(&(args->arg), tmp, str[i]); chars_written = print_it(tmp, params, str[i], chars_to_save); free(params); free(tmp); return (chars_written); }
unsigned int check_print(t_struct_arg *args, const char *str, unsigned int i, unsigned schars) { t_params *params; t_tmp_arg *tmp; unsigned int cwrite; if ((params = (t_params*)malloc(sizeof(*params))) == NULL || (tmp = (t_tmp_arg*)malloc(sizeof(*tmp))) == NULL) return (i); init_params(params); if (is_params_nbr(str + i)) i = find_good_param(params, &(args->arg_tmp), str, i); i = init_flags(params, str, i + 1); i = init_len(params, str, i); if (params->is_size == 1) params->width = va_arg(args->arg, int); if (params->is_prec == 1) params->precision = va_arg(args->arg, int); if (params->is_other == 1) stock_arg(&(args->arg_tmp), tmp, str[i]); else if (params->is_other == 0) stock_arg(&(args->arg), tmp, str[i]); cwrite = print_it(tmp, params, str[i], schars); free(params); free(tmp); return (cwrite); }
// Recursively print the hierarchy starting from the root. // If there is only one aggregate object, the hierarchy will // only be one level deep (i.e. the children of the one // aggregate). However, if there are other aggregates nested // within the top one, the printer will print each nested // aggregate with further indentation. void printer::print_it( std::ostream &out, Object *root ) { if( root == NULL ) return; if( root->PluginType() == aggregate_plugin ) { Aggregate *agg = (Aggregate *)root; out << indent() << "begin " << root->MyName() << endl; indent_n += 4; agg->Begin(); for( int n = 0; ; n++ ) { Object *obj = agg->GetChild(); if( obj == NULL ) break; if( limit > 0 && n == limit ) { // Indicate that the list has been truncated. out << indent() << "..." << endl; break; } else print_it( out, obj ); } indent_n -= 4; out << indent() << "end" << endl; } else if( root->PluginType() == primitive_plugin ) { out << indent() << root->MyName() << endl; } }
/** * gfs2_sb_print2 - Print out a superblock * @sb: the cpu-order buffer */ static void gfs2_sb_print2(struct gfs2_sb *sbp2) { gfs2_meta_header_print(&sbp2->sb_header); pv(sbp2, sb_fs_format, "%u", "0x%x"); pv(sbp2, sb_multihost_format, "%u", "0x%x"); if (sbd.gfs1) pv(sbd1, sb_flags, "%u", "0x%x"); pv(sbp2, sb_bsize, "%u", "0x%x"); pv(sbp2, sb_bsize_shift, "%u", "0x%x"); if (sbd.gfs1) { pv(sbd1, sb_seg_size, "%u", "0x%x"); gfs2_inum_print2("jindex ino", &sbd1->sb_jindex_di); gfs2_inum_print2("rindex ino", &sbd1->sb_rindex_di); } else gfs2_inum_print2("master dir", &sbp2->sb_master_dir); gfs2_inum_print2("root dir ", &sbp2->sb_root_dir); pv(sbp2, sb_lockproto, "%s", NULL); pv(sbp2, sb_locktable, "%s", NULL); if (sbd.gfs1) { gfs2_inum_print2("quota ino ", &gfs1_quota_di); gfs2_inum_print2("license ", &gfs1_license_di); } #ifdef GFS2_HAS_UUID print_it(" sb_uuid", "%s", NULL, str_uuid(sbp2->sb_uuid)); #endif }
bool printer::Run( string command, Camera &camera, Scene &scene ) { indent_n = 0; cout << "\n----- Scene printed by " << MyName() << " plugin ------" << endl; print_it( cout, scene.object ); cout << "\n" << endl; return true; }
int main (int argc, char * argv[]) { int input = 4; int * array = (int*)malloc(sizeof(int) * input); memset(array, 0, sizeof(array)); print_it(input, input, array); free(array); }
int main(void) { int n1, n2, n3; printf("Enter: "); scanf("%d %d %d", &n1, &n2, &n3); print_it(n1, n2, n3, av(n1, n2, n3)); }
void not_buggy(int size, int *b) { int z = rand()%10; if(z == 5){ free(b); b = NULL; } populate(20,b); print_it(20,b); }
/* * Prints a string (%s) * We need special handling because: * a: the length of the string is unknown * b: when .prec is used, we must not access any extra byte of the * string (of course, if the original sprintf() does... what the * hell, not my problem) * * Return value: 0 = ok * EOF = error */ static int type_s(xprintf_struct *s, int width, int prec, const char *format_string, const char *arg_string) { size_t string_len; if (arg_string == NULL) return print_it(s, (size_t)6, "(null)", 0); /* hand-made strlen() whitch stops when 'prec' is reached. */ /* if 'prec' is -1 then it is never reached. */ string_len = 0; while (arg_string[string_len] != 0 && (size_t)prec != string_len) string_len++; if (width != -1 && string_len < (size_t)width) string_len = (size_t)width; return print_it(s, string_len, format_string, arg_string); }
static void print_it(int n, int size, int * array) { if (n < 1) { int i; for ( i = 0; i < size; i++) { printf("%d", array[i]); } printf("\n"); } else { array[n - 1] = 0; print_it(n - 1, size, array); array[n - 1] = 1; print_it(n - 1, size, array); } }
NOINLINE void test_handwritten() { int counter = 2; char character = '!'; double value = 0.5; print_it("val = "); print_it(value); print_it(", cnt = "); print_it(counter); print_it(", ch = "); print_it(character); print_it(", again v="); print_it(value); print_it(";\n"); }
static int commit_buff (char *buff, char **d, FILE *out, int docstat) { if (*d > buff) { **d = '\0'; docstat = print_it (SP_STR, buff, out, docstat); *d = buff; } return docstat; }
int print_routine(char * name) { #if ASYNC_EXEC pthread_t tid; pthread_create(&tid, 0, print_it, name); pthread_join(tid, 0); #else print_it(name); #endif return 0; }
NOINLINE void test_for_each_part() { int counter = 2; char character = '!'; double value = 0.5; for_each_part(auto x, "val = $value$, cnt = $counter$, ch = $character$, again v=$value$;\n", counter, character, value) { print_it(x); }; }
NOINLINE void test_process_format() { int counter = 2; char character = '!'; double value = 0.5; auto print = [](auto x) { print_it(x); }; process_format(print, "val = $value$, cnt = $counter$, ch = $character$, again v=$value$;\n", counter, character, value); }
static int flush_doc (int docstat, FILE *out) { if (docstat & D_INIT) return D_INIT; if (fd_recurse++) { fprintf (stderr, "%s: Internal error, recursion in flush_doc()!\n", Progname); exit (1); } if (docstat & (D_PA)) docstat = print_it (SP_END_PAR, NULL, out, docstat); if (docstat & (D_TAB)) docstat = print_it (SP_END_TAB, NULL, out, docstat); if (docstat & (D_DL)) docstat = print_it (SP_END_DL, NULL, out, docstat); if (docstat & (D_EM | D_BF | D_TT)) docstat = print_it (SP_END_FT, NULL, out, docstat); docstat = print_it (SP_END_SECT, NULL, out, docstat); docstat = print_it (SP_NEWLINE, NULL, out, 0); fd_recurse--; return D_INIT; }
int main(int argc, char **argv) { t_ref *d_ref; t_mlx *d_mlx; if (argc != 2) return (0); if ((d_ref = init_ref(argv[1])) == NULL) free_ex(d_ref, 0, 0, argv[0]); if ((d_mlx = init_mlx(d_ref->win_i, d_ref->win_j, d_ref)) == NULL) free_ex(d_ref, d_mlx, 0, argv[0]); if (print_it(d_ref, d_mlx) == 0) free_ex(d_ref, d_mlx, 0, argv[0]); mlx_hook(d_mlx->win, 2, 0, (*key_hook), d_mlx); mlx_loop(d_mlx->mlx); }
int main(int argc, char **argv) { long count; static unsigned char buf[BUFSIZE]; static DES_cblock key ={0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0}; static DES_cblock key2={0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12}; static DES_cblock key3={0x56,0x78,0x9a,0xbc,0xde,0xf0,0x12,0x34}; DES_key_schedule sch,sch2,sch3; double d,tm[16],max=0; int rank[16]; char *str[16]; int max_idx=0,i,num=0,j; #ifndef SIGALARM long ca,cb,cc,cd,ce; #endif for (i=0; i<12; i++) { tm[i]=0.0; rank[i]=0; } #ifndef TIMES TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR,"To get the most accurate results, try to run this\n"); TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR,"program when this computer is idle.\n"); #endif DES_set_key_unchecked(&key,&sch); DES_set_key_unchecked(&key2,&sch2); DES_set_key_unchecked(&key3,&sch3); #ifndef SIGALRM TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR,"First we calculate the approximate speed ...\n"); DES_set_key_unchecked(&key,sch); count=10; do { long i; unsigned long data[2]; count*=2; Time_F(START); for (i=count; i; i--) DES_encrypt1(data,&(sch[0]),DES_ENCRYPT); d=Time_F(STOP); } while (d < 3.0); ca=count; cb=count*3; cc=count*3*8/BUFSIZE+1; cd=count*8/BUFSIZE+1; ce=count/20+1; #define COND(d) (count != (d)) #define COUNT(d) (d) #else #define COND(c) (run) #define COUNT(d) (count) signal(SIGALRM,sig_done); alarm(10); #endif #ifdef PART1 time_it(des_encrypt_u4_cisc_idx, "des_encrypt_u4_cisc_idx ", 0); time_it(des_encrypt_u16_cisc_idx, "des_encrypt_u16_cisc_idx ", 1); time_it(des_encrypt_u4_risc1_idx, "des_encrypt_u4_risc1_idx ", 2); num+=3; #endif #ifdef PART2 time_it(des_encrypt_u16_risc1_idx,"des_encrypt_u16_risc1_idx", 3); time_it(des_encrypt_u4_risc2_idx, "des_encrypt_u4_risc2_idx ", 4); time_it(des_encrypt_u16_risc2_idx,"des_encrypt_u16_risc2_idx", 5); num+=3; #endif #ifdef PART3 time_it(des_encrypt_u4_cisc_ptr, "des_encrypt_u4_cisc_ptr ", 6); time_it(des_encrypt_u16_cisc_ptr, "des_encrypt_u16_cisc_ptr ", 7); time_it(des_encrypt_u4_risc1_ptr, "des_encrypt_u4_risc1_ptr ", 8); num+=3; #endif #ifdef PART4 time_it(des_encrypt_u16_risc1_ptr,"des_encrypt_u16_risc1_ptr", 9); time_it(des_encrypt_u4_risc2_ptr, "des_encrypt_u4_risc2_ptr ",10); time_it(des_encrypt_u16_risc2_ptr,"des_encrypt_u16_risc2_ptr",11); num+=3; #endif #ifdef PART1 str[0]=" 4 c i"; print_it("des_encrypt_u4_cisc_idx ",0); max=tm[0]; max_idx=0; str[1]="16 c i"; print_it("des_encrypt_u16_cisc_idx ",1); if (max < tm[1]) { max=tm[1]; max_idx=1; } str[2]=" 4 r1 i"; print_it("des_encrypt_u4_risc1_idx ",2); if (max < tm[2]) { max=tm[2]; max_idx=2; } #endif #ifdef PART2 str[3]="16 r1 i"; print_it("des_encrypt_u16_risc1_idx",3); if (max < tm[3]) { max=tm[3]; max_idx=3; } str[4]=" 4 r2 i"; print_it("des_encrypt_u4_risc2_idx ",4); if (max < tm[4]) { max=tm[4]; max_idx=4; } str[5]="16 r2 i"; print_it("des_encrypt_u16_risc2_idx",5); if (max < tm[5]) { max=tm[5]; max_idx=5; } #endif #ifdef PART3 str[6]=" 4 c p"; print_it("des_encrypt_u4_cisc_ptr ",6); if (max < tm[6]) { max=tm[6]; max_idx=6; } str[7]="16 c p"; print_it("des_encrypt_u16_cisc_ptr ",7); if (max < tm[7]) { max=tm[7]; max_idx=7; } str[8]=" 4 r1 p"; print_it("des_encrypt_u4_risc1_ptr ",8); if (max < tm[8]) { max=tm[8]; max_idx=8; } #endif #ifdef PART4 str[9]="16 r1 p"; print_it("des_encrypt_u16_risc1_ptr",9); if (max < tm[9]) { max=tm[9]; max_idx=9; } str[10]=" 4 r2 p"; print_it("des_encrypt_u4_risc2_ptr ",10); if (max < tm[10]) { max=tm[10]; max_idx=10; } str[11]="16 r2 p"; print_it("des_encrypt_u16_risc2_ptr",11); if (max < tm[11]) { max=tm[11]; max_idx=11; } #endif TINYCLR_SSL_PRINTF("options des ecb/s\n"); TINYCLR_SSL_PRINTF("%s %12.2f 100.0%%\n",str[max_idx],tm[max_idx]); d=tm[max_idx]; tm[max_idx]= -2.0; max= -1.0; for (;;) { for (i=0; i<12; i++) { if (max < tm[i]) { max=tm[i]; j=i; } } if (max < 0.0) break; TINYCLR_SSL_PRINTF("%s %12.2f %4.1f%%\n",str[j],tm[j],tm[j]/d*100.0); tm[j]= -2.0; max= -1.0; } switch (max_idx) { case 0: TINYCLR_SSL_PRINTF("-DDES_DEFAULT_OPTIONS\n"); break; case 1: TINYCLR_SSL_PRINTF("-DDES_UNROLL\n"); break; case 2: TINYCLR_SSL_PRINTF("-DDES_RISC1\n"); break; case 3: TINYCLR_SSL_PRINTF("-DDES_UNROLL -DDES_RISC1\n"); break; case 4: TINYCLR_SSL_PRINTF("-DDES_RISC2\n"); break; case 5: TINYCLR_SSL_PRINTF("-DDES_UNROLL -DDES_RISC2\n"); break; case 6: TINYCLR_SSL_PRINTF("-DDES_PTR\n"); break; case 7: TINYCLR_SSL_PRINTF("-DDES_UNROLL -DDES_PTR\n"); break; case 8: TINYCLR_SSL_PRINTF("-DDES_RISC1 -DDES_PTR\n"); break; case 9: TINYCLR_SSL_PRINTF("-DDES_UNROLL -DDES_RISC1 -DDES_PTR\n"); break; case 10: TINYCLR_SSL_PRINTF("-DDES_RISC2 -DDES_PTR\n"); break; case 11: TINYCLR_SSL_PRINTF("-DDES_UNROLL -DDES_RISC2 -DDES_PTR\n"); break; } TINYCLR_SSL_EXIT(0); #if defined(LINT) || defined(OPENSSL_SYS_MSDOS) return(0); #endif }
int test_signature() { printf("Testing RSA functions with EVP_DigestSign and EVP_DigestVerify\n"); EVP_RSA_SIGN_Init(); int return_value = -1; /* Sign and Verify HMAC keys */ EVP_PKEY *pri_key = NULL, *pub_key = NULL; unsigned char* sig = NULL; do { int rc = EVP_RSA_SIGN_make_keys_by_create(&pri_key, &pub_key); //EVP_RSA_SIGN_make_keys_to_file("RSAPrivateKey.pem", "RSAPublicKey.pem"); //int rc = EVP_RSA_SIGN_make_keys_by_file(&pri_key, &pub_key, "clientPriKeyNew.pem", "clientPubKeyNew.pem"); //int rc = EVP_RSA_SIGN_make_keys_by_file(&pri_key, &pub_key, "clientPriKeyOld.pem", "clientPubKeyOld.pem"); //int rc = EVP_RSA_SIGN_make_keys_by_hmac(&pri_key, &pub_key, "wangqingsong"); assert(rc == 0); if(rc != 0) break; assert(pri_key != NULL); if(pri_key == NULL) break; assert(pub_key != NULL); if(pub_key == NULL) break; const byte msg[] = "Now is the time for all good men to come to the aide of their country"; size_t slen = 0; /* Using the skey or signing key */ rc = EVP_RSA_SIGN_Signature(msg, strlen(msg), &sig, &slen, pri_key); assert(rc == 0); if(rc == 0) { printf("Signature OK\n"); } else { printf("Failed to create signature, return code %d\n", rc); break; } print_it("Signature", sig, slen); #if 0 /* Tamper with signature */ printf("Tampering with signature\n"); sig[0] ^= 0x01; #endif #if 0 /* Tamper with signature */ printf("Tampering with signature\n"); sig[slen - 1] ^= 0x01; #endif /* Using the vkey or verifying key */ rc = EVP_RSA_SIGN_Verify(msg, strlen(msg), sig, slen, pub_key); /* if the key is created by hmac , you need use this function to verify * signature*/ //rc = EVP_RSA_SIGN_Verify_Hmac(msg, strlen(msg), sig, slen, pub_key); if(rc == 0) { printf("Verified OK\n"); } else { printf("Failed to verify signature, return code %d\n", rc); break; } print_it("Verify", sig, slen); return_value = 0; }while(0); if(sig) OPENSSL_free(sig); if(pri_key) EVP_PKEY_free(pri_key); if(pub_key) EVP_PKEY_free(pub_key); return return_value; }
static int handle_docline (char *l, FILE *out, int docstat) { char buff[BUFFSIZE]; char *s, *d; l = skip_ws (l); if (Debug) fprintf (stderr, "%s: handle_docline `%s'\n", Progname, l); if (!strncmp (l, ".pp", 3)) return print_it (SP_NEWPAR, NULL, out, docstat); else if (!strncmp (l, ".ts", 3)) return print_it (SP_START_TAB, NULL, out, docstat); else if (!strncmp (l, ".te", 3)) return print_it (SP_END_TAB, NULL, out, docstat); else if (!strncmp (l, ".dl", 3)) return print_it (SP_START_DL, NULL, out, docstat); else if (!strncmp (l, ".de", 3)) return print_it (SP_END_DL, NULL, out, docstat); else if (!strncmp (l, ".il", 3)) return print_it (SP_START_IL, NULL, out, docstat); else if (!strncmp (l, ".ie", 3)) return print_it (SP_END_IL, NULL, out, docstat); else if (!strncmp (l, ". ", 2)) *l = ' '; for (s = l, d = buff; *s; s++) { if (!strncmp (s, "\\(as", 4)) { *d++ = '*'; s += 3; } else if (!strncmp (s, "\\(rs", 4)) { *d++ = '\\'; s += 3; } else if (!strncmp (s, "\\fI", 3)) { docstat = commit_buff (buff, &d, out, docstat); docstat = print_it (SP_START_EM, NULL, out, docstat); s += 2; } else if (!strncmp (s, "\\fB", 3)) { docstat = commit_buff (buff, &d, out, docstat); docstat = print_it (SP_START_BF, NULL, out, docstat); s += 2; } else if (!strncmp (s, "\\fC", 3)) { docstat = commit_buff (buff, &d, out, docstat); docstat = print_it (SP_START_TT, NULL, out, docstat); s += 2; } else if (!strncmp (s, "\\fP", 3)) { docstat = commit_buff (buff, &d, out, docstat); docstat = print_it (SP_END_FT, NULL, out, docstat); s += 2; } else if (!strncmp (s, ".dt", 3)) { if (docstat & D_DD) { docstat = commit_buff (buff, &d, out, docstat); docstat = print_it (SP_END_DD, NULL, out, docstat); } docstat = commit_buff (buff, &d, out, docstat); docstat = print_it (SP_DT, NULL, out, docstat); s += 3; } else if (!strncmp (s, ".dd", 3)) { if ((docstat & D_IL) && (docstat & D_DD)) { docstat = commit_buff (buff, &d, out, docstat); docstat = print_it (SP_END_DD, NULL, out, docstat); } docstat = commit_buff (buff, &d, out, docstat); docstat = print_it (SP_DD, NULL, out, docstat); s += 3; } else if (*s == '$') { int output_dollar = 0; char *ref; char save; ++s; if (*s == '$') { output_dollar = 1; ++s; } if (*s == '$') { *d++ = '$'; } else { ref = s; while (isalnum ((unsigned char) *s) || (*s && strchr("-_<>", *s))) ++s; docstat = commit_buff (buff, &d, out, docstat); save = *s; *s = 0; print_ref (out, output_dollar, ref); *s = save; --s; } } else *d++ = *s; } docstat = commit_buff (buff, &d, out, docstat); return print_it (SP_NEWLINE, NULL, out, docstat); }
int main(int argc, char **argv) { /* * VARIABLES */ /* simple counter */ int i = 1; /* getopt_long-options */ static struct option long_options[] = { {"dist", required_argument, 0, 'd'}, {"in", required_argument, 0, 'i'}, {"out", required_argument, 0, 'o'}, {0, 0, 0, 0} }; /* Filepointers to in and outfile */ FILE *in; FILE *out = NULL; /* a string containing the name of the distro we are working on */ const char *distro = NULL; /* filenames, of in and outfiles */ const char *infile = NULL; const char *outfile = NULL; /* temporary data storage */ const char *data; /* space to get the line we are parsing */ char line[LINE_LEN]; /* if parsing an #exec, fill this string with #exec data */ char exec_buffer[EXEC_BUFFER_LEN]; /* The maximum exec_buffer lengt we have left to fill */ int exec_buffer_free = EXEC_BUFFER_LEN - 1; /* Current line number in input */ int lineno = 0; /* Stack - please use the macros defined below, if possible */ struct { enum_block block_type; int process_elses; int print_out; int lineno; } stack[16]; int stack_top = 0; #define POP_STACK --stack_top #define PUSH_STACK(type) ( stack[stack_top].process_elses = BLOCK_PRINTS_OUT, \ stack[stack_top].print_out = BLOCK_PRINTS_OUT, \ stack[stack_top].lineno = lineno, \ stack[stack_top++].block_type = type) #define BLOCK_PRINTS_OUT ( stack_top ? stack[stack_top-1].print_out : 1 ) #define STACK_EMPTY ( stack_top == 0 ) #define STACK_TOP ( stack[stack_top-1] ) #define IN_BLOCK ( stack_top ? stack[stack_top-1].block_type : 0 ) /* * CODE */ /* parse and fill path struct */ path = str_split(getenv("PATH"), ':'); if (!path) { fprintf(stderr, " **\tERROR: could not get $PATH\n"); exit(1); } /* Parse initial arguments */ while (-1 != (i = getopt_long(argc, argv, "hi:o:d:", long_options, NULL))) { switch (i) { /* set the distro manually */ case 'd': distro = optarg; break; /* set the file to parse */ case 'i': infile = optarg; break; /* set the outfile manually */ case 'o': outfile = optarg; break; default: fprintf(stdout, "Ups, what's that? <0%o>\n", i); } } /* if not set, probe it */ if (!distro) distro = probe_distribution(); if (!distro) { fprintf(stderr, " **\tUnknown DISTRIBUTION\n"); exit(1); } fprintf(stderr, " **\tDistribution set: \"%s\"\n", distro); /* load the overlay */ { int j; char file[200]; /* reset the ovelay */ for (j = 0; j < 1000; j++) { overlay[j].opt = NULL; overlay[j].value = NULL; } /* and distro dependent overlay, found in workdir */ sprintf(file, "%s.overlay", distro); load_overlay_file(file); /* a standard path for overlay */ strcpy(file, INITNG_ROOT); strcat(file, "/initng.overlay"); load_overlay_file(file); /*printf("Overlays found:\n"); for(j=0;j<1000 && overlay[j].opt;j++) { printf(" \"%s\" == \"%s\"\n", overlay[j].opt, overlay[j].value); } */ } /* open input for writing */ if (!infile) { fprintf(stderr, " **\tYou have to set input file with -i\n"); exit(1); } if (!(in = fopen(infile, "r"))) { fprintf(stderr, " **\tcould not open input file!\n"); exit(1); } /* make sure input is service.s */ if (!strstr(infile, ".s")) { printf("install_service_file only handles *.s files!\n"); exit(1); } /* open output for writing */ if (!outfile) { if (strstr(infile, ".s")) { outfile = strndup(infile, strlen(infile) - 2); } else { fprintf(stderr, " **\tout with -o not set, " "defaulting to stdout.\n"); out = stdout; } } if (!out && !(out = fopen(outfile, "w"))) { fprintf(stderr, " **\tcould not open output file!\n"); exit(1); } /* Print header */ fprintf(out, "#!/sbin/runiscript\n" "# This is an init script file, used by initng.\n\n"); /* Okay, go parse every line */ while (fgets(line, LINE_LEN, in)) { lineno++; /* * This is an internal set, to force an standard default path, * please us an direct @/usr/sbin/gdm@ instead. */ if (match("#atdefpath", line)) { D_("found #atdefpath. updating at default path\n"); /* get the data after #atdefpath data */ data = skip_spaces(line + LEN("#atdefpath")); /* free previous fore path */ if (at_default_path) free(at_default_path); /* allocate an new one */ at_default_path = malloc(strlen(data) + 1); /* copy the data */ i = 0; while (data[i] && data[i] != ' ' && data[i] != '\t' && data[i] != '\n') { at_default_path[i] = data[i]; i++; } at_default_path[i] = '\0'; D_("at_default_path updated to %s\n", at_default_path); /* explain */ at_default_paths = str_split(at_default_path, ':'); continue; } /* If this is an ordinary line, not starting with an # */ if (STACK_EMPTY && line[0] != '#') { /* youst print it to outfile */ print_it(out, line); continue; /* read next line */ } /* either in_block != 0 or line started with '#' */ if (IN_BLOCK == EXEC_BLOCK) { /* in_block == EXEC_BLOCK */ if (match("#endexec", line)) { D_("found #endexec, line %i\n", lineno); /* Do the exec shit */ if (BLOCK_PRINTS_OUT) { data = do_exec(exec_buffer, strlen(exec_buffer)); if (data) { print_it(out, data); free((void *)data); } } POP_STACK; continue; } else { strncat(exec_buffer, line, exec_buffer_free); exec_buffer_free -= strlen(line); continue; } } else { /* #exec is an internal run, and output will be * outputed to outfile */ if (match("#exec", line)) { D_("found #exec, line %i\n", lineno); exec_buffer[0] = '\0'; exec_buffer_free = EXEC_BUFFER_LEN - 1; PUSH_STACK(EXEC_BLOCK); continue; } else if (match("#endexec", line)) { fprintf(stderr, "ERROR: #endexec without " "#exec, line %i\n", lineno); fclose(out); if (outfile) unlink(outfile); exit(1); } /* #ifd debian, meens utput this to outfile if * distro == debian */ else if (match("#ifd", line)) { D_("found #ifd, line %i\n", lineno); PUSH_STACK(IF_BLOCK); STACK_TOP.print_out = 0; if (STACK_TOP.process_elses && match_distro(line, distro)) { D_("actual distro %s matches line " "%i: %s\n", distro, lineno, line); STACK_TOP.print_out = 1; STACK_TOP.process_elses = 0; } continue; } else if (match("#elsed", line)) { if (IN_BLOCK != IF_BLOCK) { fprintf(stderr, "ERROR: unexpected " "#elsed, line %i\n", lineno); fclose(out); if (outfile) unlink(outfile); exit(1); } if (STACK_TOP.process_elses) { if (empty_elsed(line) || match_distro(line, distro)) { STACK_TOP.print_out = 1; STACK_TOP.process_elses = 0; } } else { STACK_TOP.print_out = 0; } } else if (match("#endd", line)) { if (IN_BLOCK != IF_BLOCK) { fprintf(stderr, "ERROR: unexpected " "#endd, line %i\n", lineno); fclose(out); if (outfile) unlink(outfile); exit(1); } POP_STACK; } else { /* it's just an ordinary line */ if (BLOCK_PRINTS_OUT) print_it(out, line); continue; /* read next line */ } } } if (!STACK_EMPTY) { while (!STACK_EMPTY) { if (IN_BLOCK == EXEC_BLOCK) fprintf(stderr, "ERROR: missing #endexec for " "#exec on line %i\n", STACK_TOP.lineno); else fprintf(stderr, "ERROR: missing #endd for " "#ifd on line %i\n", STACK_TOP.lineno); POP_STACK; } fclose(out); if (outfile) unlink(outfile); exit(1); } #if 0 /* We don't really need to free anything, 'coz we will exit soon */ /* free the overlay table */ for (i = 0; i < 1000 && overlay[i].opt; i++) { free((char *)overlay[i].opt); /* const-cast */ overlay[i].opt = NULL; if (overlay[i].value) { free((char *)overlay[i].value); /* const-cast */ overlay[i].value = NULL; } } #endif /* close bouth input and output file */ fclose(in); fclose(out); if (outfile) { chmod(outfile, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); } return 0; }
int main(int argc, char **argv) { long count; static unsigned char buf[BUFSIZE]; static char key[16]={ 0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0, 0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0}; BF_KEY sch; double d,tm[16],max=0; int rank[16]; char *str[16]; int max_idx=0,i,num=0,j; #ifndef SIGALARM long ca,cb,cc,cd,ce; #endif for (i=0; i<12; i++) { tm[i]=0.0; rank[i]=0; } #ifndef TIMES fprintf(stderr,"To get the most accurate results, try to run this\n"); fprintf(stderr,"program when this computer is idle.\n"); #endif BF_set_key(&sch,16,key); #ifndef SIGALRM fprintf(stderr,"First we calculate the approximate speed ...\n"); count=10; do { long i; unsigned long data[2]; count*=2; Time_F(START); for (i=count; i; i--) BF_encrypt(data,&sch); d=Time_F(STOP); } while (d < 3.0); ca=count; cb=count*3; cc=count*3*8/BUFSIZE+1; cd=count*8/BUFSIZE+1; ce=count/20+1; #define COND(d) (count != (d)) #define COUNT(d) (d) #else #define COND(c) (run) #define COUNT(d) (count) signal(SIGALRM,sig_done); alarm(10); #endif time_it(BF_encrypt_normal, "BF_encrypt_normal ", 0); time_it(BF_encrypt_ptr, "BF_encrypt_ptr ", 1); time_it(BF_encrypt_ptr2, "BF_encrypt_ptr2 ", 2); num+=3; str[0]="<nothing>"; print_it("BF_encrypt_normal ",0); max=tm[0]; max_idx=0; str[1]="ptr "; print_it("BF_encrypt_ptr ",1); if (max < tm[1]) { max=tm[1]; max_idx=1; } str[2]="ptr2 "; print_it("BF_encrypt_ptr2 ",2); if (max < tm[2]) { max=tm[2]; max_idx=2; } printf("options BF ecb/s\n"); printf("%s %12.2f 100.0%%\n",str[max_idx],tm[max_idx]); d=tm[max_idx]; tm[max_idx]= -2.0; max= -1.0; for (;;) { for (i=0; i<3; i++) { if (max < tm[i]) { max=tm[i]; j=i; } } if (max < 0.0) break; printf("%s %12.2f %4.1f%%\n",str[j],tm[j],tm[j]/d*100.0); tm[j]= -2.0; max= -1.0; } switch (max_idx) { case 0: printf("-DBF_DEFAULT_OPTIONS\n"); break; case 1: printf("-DBF_PTR\n"); break; case 2: printf("-DBF_PTR2\n"); break; } exit(0); #if defined(LINT) || defined(OPENSSL_SYS_MSDOS) return(0); #endif }
int main(int argc, char* argv[]) { char * passwd; uint64_t N = 1 << 14; uint32_t r = 8; uint32_t p = 1; char buf[65]; size_t buflen = 64; int result; int i = 0; int punctuation = 1; // Whether to allow punctuation in the output int addbang = 0; // The the first character '!' int addfive = 0; // Make the 5th character '5' int length = 10; // Desired password length if (argc < 2) { usage(); } // Disable punctuation in output for sites that are jerks if (strcmp(argv[1], "chase.com") == 0 || strcmp(argv[1], "fandango.com") == 0 || //strcmp(argv[1], "apple.com") == 0 || strcmp(argv[1], "comcast.com") == 0 || strcmp(argv[1], "verizonwireless.com") == 0 || strcmp(argv[1], "gap.com") == 0 || strcmp(argv[1], "audible.com") == 0 || strcmp(argv[1], "purpletie.com") == 0 || strcmp(argv[1], "opentable.com") == 0 || strcmp(argv[1], "videoeta.com") == 0 || strcmp(argv[1], "topcoder.com") == 0 || strcmp(argv[1], "hondafinancialservices.com") == 0 || strcmp(argv[1], "americanexpress.com") == 0 || argc == 3) { punctuation = 0; } else if (strcmp(argv[1], "kaiserpermanente.org") == 0) { addbang = 1; } else if (strcmp(argv[1], "schwab.com") == 0) { // Schwab may have the stupidest password requirements I've ever // encountered. length = 8; addfive = 1; punctuation = 0; } else if (strcmp(argv[1], "deltadentalins.com") == 0 || strcmp(argv[1], "mozilla.org") == 0 || strcmp(argv[1], "morganstanleysmithbarney.com") == 0) { addfive = 1; } /* Prompt for a password. */ if (tarsnap_readpass(&passwd, "Please enter passphrase", NULL, 1)) { exit(1); } result = crypto_scrypt(passwd, strlen(passwd), argv[1], strlen(argv[1]), N, r, p, buf, buflen); buf[64] = 0; if (result != 0) { fprintf(stderr, "Something went wrong!\n"); print_error(errno); exit(1); } else { print_it(buf, punctuation, addbang, length, addfive); printf("\n"); } /* Zero and free the password. */ memset(passwd, 0, strlen(passwd)); free(passwd); return 0; }
//hlavni funkce starajici se o chod aplikace int main(int argc, char **argv ) { unsigned int cnt = 0,old_score=1; char_cnt = 0; last_ch = 0; //iniciaizace HW initialize_hardware(); keyboard_init(); int random_number,i,j; Tshape myshape; Tmatrix matrix,pane,pom; int pom_matrix[8][8] = {0}; char c=0; int latest_line; //srand(2); //vytvoreni noveho utvaru myshape = create_shape(rand()%8); //posun na zacatek matrix = move_it(myshape,pom_matrix); //ulozeni noveho utvaru pane = save_it(matrix,pom_matrix); set_led_d6(1); // rozsviceni D6 set_led_d5(1); // rozsviceni D5 //inicializace LED displeje P6DIR=0xff; P4DIR=0x0f; P2DIR=0xf0; P4OUT=0x00; P2OUT=0x00; P6OUT=0xff; while (1) { delay_ms(1); cnt++; //pri zmacknuti klavesy if (c!=last_ch){ c=last_ch; //pokud byla zmacknuta 6 if (c=='6'){ //posunu se x++; //pokusim se ulozit na to misto utvar matrix = move_it(myshape,pom_matrix); //pokud nelze ulozit if (matrix.count!=4){ //vratim se x--; //a ulozim matrix = move_it(myshape,pom_matrix); } } //pri zmacknuti 4 else if (c=='4'){ //posunu se x--; //pokusim se ulozit matrix = move_it(myshape,pom_matrix); //pokud bych vypsal mene jak 4 znaky z utvaru if (matrix.count!=4){ //posouvam se zpatky x++; matrix = move_it(myshape,pom_matrix); } } //pokud nactu 8 else if (c=='8'){ //posunu se y++; //pokusim se ulozit matrix = move_it(myshape,pom_matrix); if (matrix.count!=4){ //pokud nelze posun, posunu se nazpet y--; matrix = move_it(myshape,pom_matrix); matrix.last_line = 1; } } //rotace else if (c=='5'){ //pouzivam prvne rotate_back kvuli "hezci" rotaci myshape = rotate_back(myshape); //pokusim se ulozit dany utvar matrix = move_it(myshape,pom_matrix); //pokud pri posunu nelze vypsat vsechny 4 prvky daneho utvaru if (matrix.count!=4){ //posunu se zpatky myshape = rotate(myshape); matrix = move_it(myshape,pom_matrix); } } else { continue; } //ulozim do vysledneho hraciho pole pane = save_it(matrix,pom_matrix); //pokud jsem nacetl posledni radek if (matrix.last_line==1) { //ulozim si hraci pole do pomocne matice for (i=0;i<8;i++) { for (j=0;j<8;j++) { pom_matrix[i][j] = pane.shape[i][j]; } } matrix.last_line=0; //smazu radky pane=delete_rows(pane); x=0; y=0; //vygeneruji novy utvar myshape = create_shape(rand()%8); int i,t; //ulozim do pomocne matice hraci pole for (i=0;i<8;i++) for (t=0;t<8;t++) pom_matrix[i][t]=pane.shape[i][t]; //posunu nove vygenerovany utvar na zacatek hraciho pole matrix = move_it(myshape,pom_matrix); //ulozim tento stav pane = save_it(matrix,pom_matrix); } c=last_ch; } //tisknuti skore if (old_score!=score && (cnt%100)==0){ old_score=score; print_score("Score: "); } if (cnt > 1000) { cnt = 0; flip_led_d6(); // negace portu na ktere je LED } print_it(pane.shape); keyboard_idle(); // obsluha klavesnice terminal_idle(); // obsluha terminalu } return 0; }
int main(int argc,char *argv[]) { int rc; char *k, *v, *line, buf[BUFSIZ]; ght_hash_table_t *p_table=NULL; /* create hash table of size 256 */ p_table=ght_create(256); if (p_table == NULL) { print_it("Error: Could not create hash table\n"); return(1); } print_menu(); for (;;) { print_prompt(); line=fgets(buf,sizeof(buf)-1,stdin); if (line == NULL) break; switch(*line) { case 'i': { k=read_data("Enter key: "); v=read_data("Enter value: "); if (k && v) { /* insert to hash table */ rc=ght_insert(p_table, v, strlen(k), k); if (rc == 0) { print_it("Inserted: Key=%s, Value=%s\n", k,v); free(k); } else { print_it("Error: ght_insert() failed\n"); (void) free((char *) k); (void) free((char *) v); } } else { if (k) (void) free((char *) k); if (v) (void) free((char *) v); } break; } case 'r': /* replace */ { k=read_data("Enter key: "); v=read_data("Enter new value: "); if (k && v) { char * old_val; /* Replace a key in the hash table */ old_val = (char*)ght_replace(p_table, v, strlen(k), k); if (old_val != NULL) { print_it("Replaced: Key=%s, Old Value=%s, Value=%s\n", k,old_val, v); free(old_val); free(k); } else { print_it("Error: ght_replace() failed\n"); (void) free((char *) k); (void) free((char *) v); } } else { if (k) (void) free((char *) k); if (v) (void) free((char *) v); } break; } case 'h': { print_menu(); break; } case 'n': /* number of elements */ { print_it("Number elements in hash table: %d\n", ght_size(p_table)); break; } case 's': /* size of hash table */ { print_it("Hash table size: %d\n", ght_table_size(p_table)); break; } case 't': /* dump */ { const void *pk, *pv; ght_iterator_t iterator; for (pv=(char *) ght_first(p_table,&iterator, &pk); pv; pv=(char *) ght_next(p_table,&iterator, &pk)) { print_it("%s => %s\n",(char *) pk,(char *) pv); } break; } case 'd': { k=read_data("Enter key to delete: "); if (k) { v=ght_remove(p_table, strlen(k), k); if (v) { print_it("Removed %s => %s",k,v); (void) free((char *) v); } else { print_it("Error: could not find data for key %s\n", k); } (void) free((char *) k); } break; } case 'l': { k=read_data("Enter key: "); if (k) { v=(char *) ght_get(p_table,strlen(k),k); if (v) { print_it("Found: %s => %s\n",k,v); } else { print_it("No data found for key: %s\n",k); } (void) free((char *) k); } break; } case 'q': { if (p_table) { const void *pv, *pk; ght_iterator_t iterator; for (pv=(char *) ght_first(p_table,&iterator, &pk); pv; pv=(char *) ght_next(p_table,&iterator, &pk)) { (void) free((char *) pv); } ght_finalize(p_table); } return(0); break; } default: { print_it("Unknown option\n"); break; } } } return(0); }