void print_data(calc* divisions, int* quantity, int* divs) { int length = 1 + (*quantity) * (*divs); make_pad(&length); n_print_calc(divisions, &qua, &div); }
feeReturn feePubKeyCreatePad(feePubKey myKey, feePubKey theirKey, unsigned char **padData, /* RETURNED */ unsigned *padDataLen) /* RETURNED padData length in bytes */ { pubKeyInst *myPkinst = (pubKeyInst *) myKey; pubKeyInst *theirPkinst = (pubKeyInst *) theirKey; giant pad; unsigned char *result; unsigned padLen; key pkey; /* * Do some compatibility checking (myKey, theirKey) here...? */ if(DEFAULT_CURVE == CURVE_PLUS) { pkey = theirPkinst->plus; } else { pkey = theirPkinst->minus; } pad = make_pad(myPkinst->privGiant, pkey); result = mem_from_giant(pad, &padLen); freeGiant(pad); /* * Ensure we have a the minimum necessary for DES. A bit of a hack, * to be sure. */ if(padLen >= FEE_DES_MIN_STATE_SIZE) { *padData = result; *padDataLen = padLen; } else { *padData = (unsigned char*) fmalloc(FEE_DES_MIN_STATE_SIZE); *padDataLen = FEE_DES_MIN_STATE_SIZE; bzero(*padData, FEE_DES_MIN_STATE_SIZE); bcopy(result, *padData, padLen); ffree(result); } return FR_Success; }
/* * Diffie-Hellman. Public key is specified either as a feePubKey or * a ANSI X9.62 format public key string (0x04 | x | y). In either case * the caller must ensure that the two keys are on the same curve. * Output data is fmalloc'd here; caller must free. Output data is * exactly the size of the curve's modulus in bytes. */ feeReturn feePubKeyECDH( feePubKey privKey, /* one of the following two is non-NULL */ feePubKey pubKey, const unsigned char *pubKeyStr, unsigned pubKeyStrLen, /* output fmallocd and RETURNED here */ unsigned char **output, unsigned *outputLen) { feePubKey theirPub = pubKey; feeReturn frtn = FR_Success; pubKeyInst *privInst = (pubKeyInst *) privKey; if(privInst->privGiant == NULL) { dbgLog(("feePubKeyECDH: privKey not a private key\n")); return FR_IncompatibleKey; } if(theirPub == NULL) { if(pubKeyStr == NULL) { return FR_IllegalArg; } /* Cook up a public key with the same curveParams as the private key */ feeDepth depth; frtn = curveParamsDepth(privInst->cp, &depth); if(frtn) { return frtn; } theirPub = feePubKeyAlloc(); if(theirPub == NULL) { return FR_Memory; } frtn = feePubKeyInitFromECDSAPubBlob(theirPub, pubKeyStr, pubKeyStrLen, depth); if(frtn) { goto errOut; } } pubKeyInst *pubInst = (pubKeyInst *) theirPub; giant outputGiant = make_pad(privInst->privGiant, pubInst->plus); if(outputGiant == NULL) { dbgLog(("feePubKeyECDH: make_pad error\n")); frtn = FR_Internal; } else { *outputLen = (privInst->cp->q + 7) / 8; *output = (unsigned char *)fmalloc(*outputLen); if(*output == NULL) { frtn = FR_Memory; goto errOut; } serializeGiant(outputGiant, *output, *outputLen); freeGiant(outputGiant); } errOut: if((pubKey == NULL) && (theirPub != NULL)) { feePubKeyFree(theirPub); } return frtn; }
/* * THE (s)printf() function. * It returns a pointer to it's internal buffer (or a string in the text * segment) thus, the string must be copied if it has to survive after * this function is called again, or if it's going to be modified (esp. * if it risks being free()ed). */ char *string_print_formatted (const char * format_str, int argc, svalue_t * argv) { format_info finfo; svalue_t *carg; /* current arg */ unsigned int nelemno = 0; /* next offset into array */ unsigned int fpos; /* position in format_str */ int fs; /* field size */ int pres; /* precision */ pad_info_t pad; /* fs pad string */ unsigned int i; char *retvalue; int last; push_sprintf_state(); STACK_INC; sp->type = T_ERROR_HANDLER; sp->u.error_handler = pop_sprintf_state; last = 0; for (fpos = 0; 1; fpos++) { char c = format_str[fpos]; if (c == '\n' || !c) { int column_stat = 0; if (last != fpos) { add_nstr(format_str + last, fpos - last); last = fpos + 1; } else last++; if (!sprintf_state->csts) { if (!c) break; ADD_CHAR('\n'); continue; } ADD_CHAR('\n'); while (sprintf_state->csts) { cst **temp; temp = &(sprintf_state->csts); while (*temp) { if ((*temp)->info & INFO_COLS) { if (*((*temp)->d.col - 1) != '\n') while (*((*temp)->d.col) == ' ') (*temp)->d.col++; add_pad(0, (*temp)->start - get_curpos()); column_stat = add_column(temp, 0); if (!column_stat) temp = &((*temp)->next); } else { add_pad(0, (*temp)->start - get_curpos()); if (!add_table(temp)) temp = &((*temp)->next); } } /* of while (*temp) */ if (sprintf_state->csts || c == '\n') ADD_CHAR('\n'); } /* of while (sprintf_state->csts) */ if (column_stat == 2) ADD_CHAR('\n'); if (!c) break; } else if (c == '%') { if (last != fpos) { add_nstr(format_str + last, fpos - last); last = fpos + 1; } else last++; if (format_str[fpos + 1] == '%') { ADD_CHAR('%'); fpos++; last++; continue; } GET_NEXT_ARG; fs = 0; pres = 0; pad.len = 0; finfo = 0; for (fpos++; !(finfo & INFO_T); fpos++) { if (!format_str[fpos]) { finfo |= INFO_T_ERROR; break; } if (((format_str[fpos] >= '0') && (format_str[fpos] <= '9')) || (format_str[fpos] == '*')) { if (pres == -1) { /* then looking for pres */ if (format_str[fpos] == '*') { if (carg->type != T_NUMBER) ERROR(ERR_INVALID_STAR); pres = carg->u.number; GET_NEXT_ARG; continue; } pres = format_str[fpos] - '0'; for (fpos++; (format_str[fpos] >= '0') && (format_str[fpos] <= '9'); fpos++) { pres = pres * 10 + format_str[fpos] - '0'; } if (pres < 0) pres = 0; } else { /* then is fs (and maybe pres) */ if ((format_str[fpos] == '0') && (((format_str[fpos + 1] >= '1') && (format_str[fpos + 1] <= '9')) || (format_str[fpos + 1] == '*'))) { pad.what = "0"; pad.len = 1; } else { if (format_str[fpos] == '*') { if (carg->type != T_NUMBER) ERROR(ERR_INVALID_STAR); fs = carg->u.number; if (fs < 0) fs = 0; if (pres == -2) pres = fs; /* colon */ GET_NEXT_ARG; continue; } fs = format_str[fpos] - '0'; } for (fpos++; (format_str[fpos] >= '0') && (format_str[fpos] <= '9'); fpos++) { fs = fs * 10 + format_str[fpos] - '0'; } if (fs < 0) fs = 0; if (pres == -2) { /* colon */ pres = fs; } } fpos--; /* about to get incremented */ continue; } switch (format_str[fpos]) { case ' ': finfo |= INFO_PP_SPACE; break; case '+': finfo |= INFO_PP_PLUS; break; case '-': finfo |= INFO_J_LEFT; break; case '|': finfo |= INFO_J_CENTRE; break; case '@': finfo |= INFO_ARRAY; break; case '=': finfo |= INFO_COLS; break; case '#': finfo |= INFO_TABLE; break; case '.': pres = -1; break; case ':': pres = -2; break; #ifdef DEBUG case '%': finfo |= INFO_T_NULL; break; /* never reached */ #endif case 'O': finfo |= INFO_T_LPC; break; case 's': finfo |= INFO_T_STRING; break; case 'd': case 'i': finfo |= INFO_T_INT; break; case 'f': finfo |= INFO_T_FLOAT; break; case 'c': finfo |= INFO_T_CHAR; break; case 'o': finfo |= INFO_T_OCT; break; case 'x': finfo |= INFO_T_HEX; break; case 'X': finfo |= INFO_T_C_HEX; break; case '\'': fpos++; pad.what = format_str + fpos; while (1) { if (!format_str[fpos]) ERROR(ERR_UNEXPECTED_EOS); if (format_str[fpos] == '\\') { if (!format_str[++fpos]) ERROR(ERR_UNEXPECTED_EOS); } else if (format_str[fpos] == '\'') { pad.len = format_str + fpos - pad.what; if (!pad.len) ERROR(ERR_NULL_PS); break; } fpos++; } break; default: finfo |= INFO_T_ERROR; } } /* end of for () */ if (pres < 0) ERROR(ERR_PRES_EXPECTED); /* * now handle the different arg types... */ if (finfo & INFO_ARRAY) { if (carg->type != T_ARRAY) ERROR(ERR_ARRAY_EXPECTED); if (carg->u.arr->size == 0) { last = fpos; fpos--; /* 'bout to get incremented */ continue; } carg = (argv + sprintf_state->cur_arg)->u.arr->item; nelemno = 1; /* next element number */ } while (1) { if ((finfo & INFO_T) == INFO_T_LPC) { outbuffer_t outbuf; outbuf_zero(&outbuf); svalue_to_string(carg, &outbuf, 0, 0, 0); outbuf_fix(&outbuf); sprintf_state->clean.type = T_STRING; sprintf_state->clean.subtype = STRING_MALLOC; sprintf_state->clean.u.string = outbuf.buffer; carg = &(sprintf_state->clean); finfo ^= INFO_T_LPC; finfo |= INFO_T_STRING; } if ((finfo & INFO_T) == INFO_T_ERROR) { ERROR(ERR_INVALID_FORMAT_STR); #ifdef DEBUG } else if ((finfo & INFO_T) == INFO_T_NULL) { /* never reached... */ fprintf(stderr, "/%s: (s)printf: INFO_T_NULL.... found.\n", current_object->obname); ADD_CHAR('%'); #endif } else if ((finfo & INFO_T) == INFO_T_STRING) { int slen; /* * %s null handling added 930709 by Luke Mewburn * <*****@*****.**> */ if (carg->type == T_NUMBER && carg->u.number == 0) { sprintf_state->clean.type = T_STRING; sprintf_state->clean.subtype = STRING_MALLOC; sprintf_state->clean.u.string = string_copy(NULL_MSG, "sprintf NULL"); carg = &(sprintf_state->clean); } else if (carg->type != T_STRING) { ERROR(ERR_INCORRECT_ARG_S); } slen = SVALUE_STRLEN(carg); if ((finfo & INFO_COLS) || (finfo & INFO_TABLE)) { cst **temp; if (!fs) { ERROR(ERR_CST_REQUIRES_FS); } temp = &(sprintf_state->csts); while (*temp) temp = &((*temp)->next); if (finfo & INFO_COLS) { int tmp; if (pres > fs) pres = fs; *temp = ALLOCATE(cst, TAG_TEMPORARY, "string_print: 3"); (*temp)->next = 0; (*temp)->d.col = carg->u.string; (*temp)->pad = make_pad(&pad); (*temp)->size = fs; (*temp)->pres = (pres) ? pres : fs; (*temp)->info = finfo; (*temp)->start = get_curpos(); #ifdef TCC puts("tcc has some bugs"); #endif tmp = ((format_str[fpos] != '\n') && (format_str[fpos] != '\0')) || ((finfo & INFO_ARRAY) && (nelemno < (argv + sprintf_state->cur_arg)->u.arr->size)); tmp = add_column(temp, tmp); if (tmp == 2 && !format_str[fpos]) { ADD_CHAR('\n'); } } else {/* (finfo & INFO_TABLE) */ unsigned int n, len, max_len; const char *p1, *p2; #define TABLE carg->u.string (*temp) = ALLOCATE(cst, TAG_TEMPORARY, "string_print: 4"); (*temp)->d.tab = 0; (*temp)->pad = make_pad(&pad); (*temp)->info = finfo; (*temp)->start = get_curpos(); (*temp)->next = 0; max_len = 0; n = 1; p2 = p1 = TABLE; while (*p1) { if (*p1 == '\n') { if (p1 - p2 > max_len) max_len = p1 - p2; p1++; if (*(p2 = p1)) n++; } else p1++; } if (!pres) { /* the null terminated word */ if (p1 - p2 > max_len) max_len = p1 - p2; pres = fs / (max_len + 2); /* at least two * separating spaces */ if (!pres) pres = 1; /* This moves some entries from the right side * of the table to fill out the last line, * which makes the table look a bit nicer. * E.g. * (n=13,p=6) (l=3,p=5) * X X X X X X X X X X X * X X X X X X -> X X X X X * X X X X X * */ len = (n-1)/pres + 1; if (n > pres && n % pres) pres -= (pres - n % pres) / len; } else { len = (n-1)/pres + 1; } (*temp)->size = fs / pres; (*temp)->remainder = fs % pres; if (n < pres) { /* If we have fewer elements than columns, * pretend we are dealing with a smaller * table. */ (*temp)->remainder += (pres - n)*((*temp)->size); pres = n; } (*temp)->d.tab = CALLOCATE(pres + 1, tab_data_t, TAG_TEMPORARY, "string_print: 5"); (*temp)->nocols = pres; /* heavy sigh */ (*temp)->d.tab[0].start = TABLE; if (pres == 1) { (*temp)->d.tab[1].start = TABLE + SVALUE_STRLEN(carg) + 1; } else { i = 1; /* the next column number */ n = 0; /* the current "word" number in this * column */ p1 = TABLE; while (*p1) { if (*p1++ == '\n' && ++n >= len) { (*temp)->d.tab[i++].start = p1; n = 0; } } for ( ; i <= pres; i++) (*temp)->d.tab[i].start = ++p1; } for (i = 0; i < pres; i++) (*temp)->d.tab[i].cur = (*temp)->d.tab[i].start; add_table(temp); } } else { /* not column or table */ const char *tmp = carg->u.string; //work around tcc bug; if (pres && pres < slen) slen = pres; add_justified(tmp, slen, &pad, fs, finfo, (((format_str[fpos] != '\n') && (format_str[fpos] != '\0')) || ((finfo & INFO_ARRAY) && (nelemno < (argv + sprintf_state->cur_arg)->u.arr->size))) || carg->u.string[slen - 1] != '\n'); } } else if (finfo & INFO_T_INT) { /* one of the integer * types */ char cheat[20]; char temp[100]; *cheat = '%'; i = 1; switch (finfo & INFO_PP) { case INFO_PP_SPACE: cheat[i++] = ' '; break; case INFO_PP_PLUS: cheat[i++] = '+'; break; } if (pres) { cheat[i++] = '.'; if(pres >= sizeof(temp)) sprintf(cheat + i, "%ld", sizeof(temp) - 1); else sprintf(cheat + i, "%d", pres); i += strlen(cheat + i); } switch (finfo & INFO_T) { case INFO_T_INT: cheat[i++] = 'l'; cheat[i++] = 'd'; break; case INFO_T_FLOAT: cheat[i++] = 'f'; break; case INFO_T_CHAR: cheat[i++] = 'c'; break; case INFO_T_OCT: cheat[i++] = 'l'; cheat[i++] = 'o'; break; case INFO_T_HEX: cheat[i++] = 'l'; cheat[i++] = 'x'; break; case INFO_T_C_HEX: cheat[i++] = 'l'; cheat[i++] = 'X'; break; default: ERROR(ERR_BAD_INT_TYPE); } if ((cheat[i - 1] == 'f' && carg->type != T_REAL) || (cheat[i - 1] != 'f' && carg->type != T_NUMBER)) { #ifdef RETURN_ERROR_MESSAGES sprintf(buff, "ERROR: (s)printf(): Incorrect argument type to %%%c. (arg: %u)\n", cheat[i - 1], sprintf_state->cur_arg); fprintf(stderr, "Program /%s File: %s: %s", current_prog->name, get_line_number_if_any(), buff); debug_message("%s", buff); if (current_object) { debug_message("program: /%s, object: %s, file: %s\n", current_prog ? current_prog->name : "", current_object->name, get_line_number_if_any()); } ERROR(ERR_RECOVERY_ONLY); #else error("ERROR: (s)printf(): Incorrect argument type to %%%c.\n", cheat[i - 1]); #endif /* RETURN_ERROR_MESSAGES */ } cheat[i] = '\0'; if (carg->type == T_REAL) { sprintf(temp, cheat, carg->u.real); } else sprintf(temp, cheat, carg->u.number); { int tmpl = strlen(temp); add_justified(temp, tmpl, &pad, fs, finfo, (((format_str[fpos] != '\n') && (format_str[fpos] != '\0')) || ((finfo & INFO_ARRAY) && (nelemno < (argv + sprintf_state->cur_arg)->u.arr->size)))); } } else /* type not found */ ERROR(ERR_UNDEFINED_TYPE); if (sprintf_state->clean.type != T_NUMBER) { free_svalue(&(sprintf_state->clean), "string_print_formatted"); sprintf_state->clean.type = T_NUMBER; } if (!(finfo & INFO_ARRAY)) break; if (nelemno >= (argv + sprintf_state->cur_arg)->u.arr->size) break; carg = (argv + sprintf_state->cur_arg)->u.arr->item + nelemno++; } /* end of while (1) */ last = fpos; fpos--; /* bout to get incremented */ } } /* end of for (fpos=0; 1; fpos++) */ outbuf_fix(&sprintf_state->obuff); retvalue = sprintf_state->obuff.buffer; sprintf_state->obuff.buffer = 0; pop_stack(); /* pop off our error handler, will call pop_sprintf_state */ return retvalue; } /* end of string_print_formatted() */
void print_harmonics(harmonic* harm_series, int* quantity) { make_pad(quantity); n_print_harmonics(harm_series, quantity); }