void sc_tcp_server_close(struct sc_tcp_server *self) { assert(self->connect.fd >= 0); assert(!ev_is_active(&self->connect)); sc_close(&self->connect.fd); }
static int sc_init(void) { int r; r = sc_establish_context(&ctx, "openssh"); if (r) goto err; if (sc_reader_id >= ctx->reader_count) { r = SC_ERROR_NO_READERS_FOUND; error("Illegal reader number %d (max %d)", sc_reader_id, ctx->reader_count -1); goto err; } r = sc_connect_card(ctx->reader[sc_reader_id], 0, &card); if (r) goto err; r = sc_pkcs15_bind(card, &p15card); if (r) goto err; return 0; err: sc_close(); return r; }
static int sc_open(void) { int sw; if (sc_fd >= 0) return sc_fd; sc_fd = sectok_friendly_open(sc_reader_id, STONOWAIT, &sw); if (sc_fd < 0) { error("sectok_open failed: %s", sectok_get_sw(sw)); return SCARD_ERROR_FAIL; } if (! sectok_cardpresent(sc_fd)) { debug("smartcard in reader %s not present, skipping", sc_reader_id); sc_close(); return SCARD_ERROR_NOCARD; } if (sectok_reset(sc_fd, 0, NULL, &sw) <= 0) { error("sectok_reset failed: %s", sectok_get_sw(sw)); sc_fd = -1; return SCARD_ERROR_FAIL; } if ((cla = cyberflex_inq_class(sc_fd)) < 0) cla = 0; debug("sc_open ok %d", sc_fd); return sc_fd; }
/* $$$ ben : used sign for testing dcload direct handle or bufferised access. */ static void dcload_close_handler(uint32 hnd) { int oldirq = 0; dcload_handler_t *dh; if (!hnd) { return; } dh = dcload_get_buffer_handler(hnd); if (dh) { hnd = dh->hdl; free(dh); } if (hnd > 100) { /* hack */ STOPIRQ; sc_closedir(hnd); STARTIRQ; } else { hnd--; /* KOS uses 0 for error, not -1 */ STOPIRQ; sc_close(hnd); STARTIRQ; } }
static int dumpfn(void *arg) { int i; struct args_t *args = arg; int *pfd = args->pfd; char *argv[] = { "iptables-save", "-c", NULL }; i = real_env_create(args->veid, VE_ENTER|VE_SKIPLOCK, 2, NULL, 0); if (i < 0) { eprintk("cannot enter ve to dump iptables\n"); module_put(THIS_MODULE); return 255 << 8; } if (pfd[1] != 1) sc_dup2(pfd[1], 1); for (i=0; i<current->files->fdt->max_fds; i++) { if (i != 1) sc_close(i); } module_put(THIS_MODULE); set_fs(KERNEL_DS); i = sc_execve("/sbin/iptables-save", argv, NULL); if (i == -ENOENT) i = sc_execve("/usr/sbin/iptables-save", argv, NULL); eprintk("failed to exec iptables-save: %d\n", i); return 255 << 8; }
static int sc_finish(RSA *rsa) { if (orig_finish) orig_finish(rsa); sc_close(); return 1; }
int main() { sc_open(); sc_sprint("test\rme\ntoo",0,0,0); sc_close(); return 0; }
static struct file *sock_mapfile(struct socket *sock) { int fd = sock_map_fd(sock, 0); if (fd >= 0) { struct file *file = sock->file; get_file(file); sc_close(fd); return file; } return ERR_PTR(fd); }
int main(int argc, char *argv[]) { e_int32 ret,i; hd_connect_t connect; msg_monitor_t monitor = { 0 }; ethread_t* threads[MAX_CLIENT_SIZE]; e_uint8 name[128]={'t','e','s','t',0}; ret = sc_open_socket(&connect, "127.0.0.1", 6666); e_assert(ret>0, ret); ret = sc_connect(&connect); e_assert(ret>0, ret); ret = mm_init(&monitor, &connect); e_assert(ret>0, ret); mm_start(&monitor); #if 0 fsocket_t* fd = mm_create_socket(&monitor, name); if (!fd) { DMSG((STDOUT,"ERROR CREATE FAKE SOCKET\r\n")); } else{ request_thread(fd); } #else while (count--) { sprintf(name,"Thread[%d]",count); fsocket_t* fd = mm_create_socket(&monitor,name); DMSG((STDOUT,"create request thread %d\r\n",count)); ret = createthread("request", (thread_func) &request_thread, (void*) fd, NULL, &threads[count]); if (ret <= 0) { DMSG((STDOUT,"createhread failed!\r\n")); return E_ERROR; } ret = resumethread(threads[count]); if (ret <= 0) { DMSG((STDOUT,"resumethread failed!\r\n")); return E_ERROR; } } #endif while(count<MAX_CLIENT_SIZE-1) { //DMSG((STDOUT,"COUNT = %d",count)); sleep(1); } for (i=0;i<MAX_CLIENT_SIZE;i++) { killthread( threads[i]); } mm_stop(&monitor); sc_close(&connect); return 0; }
static int sc_finish(RSA *rsa) { struct sc_priv_data *priv; priv = RSA_get_app_data(rsa); priv->ref_count--; if (priv->ref_count == 0) { free(priv); sc_close(); } if (orig_finish) orig_finish(rsa); return 1; }
static int sc_enable_applet(void) { static u_char aid[] = {0xfc, 0x53, 0x73, 0x68, 0x2e, 0x62, 0x69, 0x6e}; int sw = 0; /* select applet id */ sectok_apdu(sc_fd, cla, 0xa4, 0x04, 0, sizeof aid, aid, 0, NULL, &sw); if (!sectok_swOK(sw)) { error("sectok_apdu failed: %s", sectok_get_sw(sw)); sc_close(); return -1; } return 0; }
void dcload_close(uint32 hnd) { if (!tool_ip) return; net_lock(); #ifndef BENPATCH if (hnd > 100) /* hack */ sc_closedir(hnd); else sc_close(hnd-1); #else dcload_close_handler(hnd); #endif net_unlock(); }
static int sc_private_encrypt(int flen, u_char *from, u_char *to, RSA *rsa, int padding) { u_char *padded = NULL; int sw, len, status = -1; len = sw = 0; if (sc_fd < 0) { status = sc_init(); if (status < 0 ) goto err; } if (padding != RSA_PKCS1_PADDING) goto err; debug("sc_private_encrypt called"); len = BN_num_bytes(rsa->n); padded = xmalloc(len); if (RSA_padding_add_PKCS1_type_1(padded, len, (u_char *)from, flen) <= 0) { error("RSA_padding_add_PKCS1_type_1 failed"); goto err; } sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, padded, len, to, &sw); if (sw == 0x6982) { if (try_AUT0() < 0) goto err; sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, padded, len, to, &sw); } if (!sectok_swOK(sw)) { error("sc_private_encrypt: INS_DECRYPT failed: %s", sectok_get_sw(sw)); goto err; } err: if (padded) xfree(padded); sc_close(); return (len >= 0 ? len : status); }
int main(void) { int fd; int r; fd = sc_open("/tmp/test", O_RDWR | O_CREAT | O_TRUNC, 0777); if (fd == -1) { fprintf(stderr, "fail to open file.\n"); return -1; } fprintf(stderr, "fd: %d.\n", fd); r = sc_write(fd, "Hello.\n", 7); fprintf(stderr, "r: %d.\n", r); r = sc_close(fd); fprintf(stderr, "r: %d.\n", r); return 0; }
static int dumpfn(void *arg) { int i; int *pfd = arg; char *argv[] = { "iptables-restore", "-c", NULL }; if (pfd[0] != 0) sc_dup2(pfd[0], 0); for (i=1; i<current->files->fdt->max_fds; i++) sc_close(i); module_put(THIS_MODULE); set_fs(KERNEL_DS); i = kernel_execve("/sbin/iptables-restore", argv, NULL); if (i == -ENOENT) i = kernel_execve("/usr/sbin/iptables-restore", argv, NULL); eprintk("failed to exec iptables-restore: %d\n", i); return 255 << 8; }
static inline int init_tcp(struct sc_tcp_server *self, const struct sc_tcp_server_settings *settings, struct sockaddr *sa, socklen_t sa_len, int f, unsigned backlog) { int fd = sc_socket(sa->sa_family, SOCK_STREAM, 0, f); if (fd < 0) return -1; assert(self); assert(settings); if (sa->sa_family != AF_LOCAL) { int flags = 1; struct linger ling = { 0,0 }; setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void*)&flags, sizeof(flags)); setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void*)&flags, sizeof(flags)); setsockopt(fd, SOL_SOCKET, SO_LINGER, (void*)&ling, sizeof(ling)); } ev_io_init(&self->connect, connect_callback, fd, EV_READ); self->settings = settings; if (settings->pre_bind) settings->pre_bind(self); if (bind(fd, sa, sa_len) <0 || listen(fd, backlog)<0) { int e = errno; sc_close(&self->connect.fd); errno=e; return -1; } return 1; }
static int sc_private_decrypt(int flen, u_char *from, u_char *to, RSA *rsa, int padding) { struct sc_pkcs15_object *key_obj; int r; if (padding != RSA_PKCS1_PADDING) return -1; r = sc_prkey_op_init(rsa, &key_obj, SC_USAGE_DECRYPT); if (r) return -1; r = sc_pkcs15_decipher(p15card, key_obj, SC_ALGORITHM_RSA_PAD_PKCS1, from, flen, to, flen); sc_unlock(card); if (r < 0) { error("sc_pkcs15_decipher() failed: %s", sc_strerror(r)); goto err; } return r; err: sc_close(); return -1; }
static int sc_sign(int type, u_char *m, unsigned int m_len, unsigned char *sigret, unsigned int *siglen, RSA *rsa) { struct sc_pkcs15_object *key_obj; int r; unsigned long flags = 0; /* XXX: sc_prkey_op_init will search for a pkcs15 private * key object with the sign or signrecover usage flag set. * If the signing key has only the non-repudiation flag set * the key will be rejected as using a non-repudiation key * for authentication is not recommended. Note: This does not * prevent the use of a non-repudiation key for authentication * if the sign or signrecover flag is set as well. */ r = sc_prkey_op_init(rsa, &key_obj, SC_USAGE_SIGN); if (r) return -1; /* FIXME: length of sigret correct? */ /* FIXME: check 'type' and modify flags accordingly */ flags = SC_ALGORITHM_RSA_PAD_PKCS1 | SC_ALGORITHM_RSA_HASH_SHA1; r = sc_pkcs15_compute_signature(p15card, key_obj, flags, m, m_len, sigret, RSA_size(rsa)); sc_unlock(card); if (r < 0) { error("sc_pkcs15_compute_signature() failed: %s", sc_strerror(r)); goto err; } *siglen = r; return 1; err: sc_close(); return 0; }
void catch_signal(int sig) { sc_close(); }
static int cpt_dump_iptables(struct cpt_context * ctx) { int err = 0; #ifdef CONFIG_VE_IPTABLES int pid; int pfd[2]; struct file *f; struct cpt_object_hdr v; char buf[16]; loff_t pos; int n; int status; mm_segment_t oldfs; sigset_t ignore, blocked; struct args_t args; struct ve_struct *oldenv; if (!(get_exec_env()->_iptables_modules & VE_IP_IPTABLES_MOD)) return 0; err = sc_pipe(pfd); if (err < 0) { eprintk_ctx("sc_pipe: %d\n", err); return err; } args.pfd = pfd; args.veid = VEID(get_exec_env()); ignore.sig[0] = CPT_SIG_IGNORE_MASK; sigprocmask(SIG_BLOCK, &ignore, &blocked); oldenv = set_exec_env(get_ve0()); err = pid = local_kernel_thread(dumpfn, (void*)&args, SIGCHLD | CLONE_VFORK, 0); set_exec_env(oldenv); if (err < 0) { eprintk_ctx("local_kernel_thread: %d\n", err); goto out; } f = fget(pfd[0]); sc_close(pfd[1]); sc_close(pfd[0]); cpt_open_section(ctx, CPT_SECT_NET_IPTABLES); cpt_open_object(NULL, ctx); v.cpt_next = CPT_NULL; v.cpt_object = CPT_OBJ_NAME; v.cpt_hdrlen = sizeof(v); v.cpt_content = CPT_CONTENT_NAME; ctx->write(&v, sizeof(v), ctx); pos = ctx->file->f_pos; do { oldfs = get_fs(); set_fs(KERNEL_DS); n = f->f_op->read(f, buf, sizeof(buf), &f->f_pos); set_fs(oldfs); if (n > 0) ctx->write(buf, n, ctx); } while (n > 0); if (n < 0) eprintk_ctx("read: %d\n", n); fput(f); oldfs = get_fs(); set_fs(KERNEL_DS); if ((err = sc_waitx(pid, 0, &status)) < 0) eprintk_ctx("wait4: %d\n", err); else if ((status & 0x7f) == 0) { err = (status & 0xff00) >> 8; if (err != 0) { eprintk_ctx("iptables-save exited with %d\n", err); err = -EINVAL; } } else {
int calculate_track_dr(const char *filename, struct track_info *t, int number) { struct stream_context sc; struct dr_meter meter; int err; meter_init(&meter); err = sc_open(&sc, filename); if (err < 0) { return print_av_error("sc_open", err); } if (debug) { printf("DEBUG: Codec: %s\n", avcodec_get_name(sc_get_codec_id(&sc))); } int stream_index = err = av_find_best_stream( sc.format_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0); if (err < 0) { print_av_error("av_find_best_stream", err); goto cleanup; } err = sc_start_stream(&sc, stream_index); if (err < 0) { print_av_error("sc_start_stream", err); goto cleanup; } t->artist = strdup(sc_get_metadata(&sc, "artist")); t->album = strdup(sc_get_metadata(&sc, "album")); t->tracknumber = strdup(sc_get_metadata(&sc, "track")); t->title = strdup(sc_get_metadata(&sc, "title")); AVCodecParameters *codecpar = sc_get_codec_parameters(&sc); err = meter_start(&meter, codecpar->channels, codecpar->sample_rate, codecpar->format); if (err) { goto cleanup; } size_t fragment = 0; int throbbler_stage = 0; while (!sc_eof(&sc)) { err = sc_get_next_frame(&sc); if (err < 0) { print_av_error("sc_get_next_frame", err); goto cleanup; } err = meter_feed(&meter, sc_get_buf(&sc), sc_get_samples(&sc)); if (err) { goto cleanup; } if (fragment < meter.fragment) { fragment = meter.fragment; if ((throbbler_stage % 4) == 0) { fprintf(stderr, "\033[1K\033[1G" "Analyzing track %i... " "%c %2zu:%02zu ", number, throbbler[throbbler_stage / 4], (fragment * 3) / 60, (fragment * 3) % 60); } throbbler_stage += 1; throbbler_stage %= 16; } } fprintf(stderr, "\033[1K\033[1G"); meter_finish(&meter, t); cleanup: meter_free(&meter); sc_close(&sc); if (err < 0) { return err; } return 0; }
int do_calculate_dr(const char *filename) { struct stream_context sc; struct dr_meter meter; int err; meter_init(&meter); err = sc_open(&sc, filename); if (err < 0) { return print_av_error("sc_open", err); } int stream_index = err = av_find_best_stream( sc.format_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0); if (err < 0) { print_av_error("av_find_best_stream", err); goto cleanup; } err = sc_start_stream(&sc, stream_index); if (err < 0) { print_av_error("sc_start_stream", err); goto cleanup; } // Print out the stream info AVCodecContext *codec_ctx = sc_get_codec(&sc); char codecinfobuf[256]; avcodec_string(codecinfobuf, sizeof(codecinfobuf), codec_ctx, 0); fprintf(stderr, "%.256s\n", codecinfobuf); err = meter_start(&meter, codec_ctx->channels, codec_ctx->sample_rate, codec_ctx->sample_fmt); if (err) { goto cleanup; } fprintf(stderr, "Collecting fragments information...\n"); size_t fragment = 0; int throbbler_stage = 0; while (!sc_eof(&sc)) { err = sc_get_next_frame(&sc); if (err < 0) { print_av_error("sc_get_next_frame", err); goto cleanup; } err = meter_feed(&meter, sc.buf, sc.buf_size); if (err) { goto cleanup; } if (fragment < meter.fragment) { fragment = meter.fragment; if ((throbbler_stage % 4) == 0) { fprintf(stderr, "\033[1K\033[1G %c %2i:%02i ", throbbler[throbbler_stage / 4], (fragment * 3) / 60, (fragment * 3) % 60); } throbbler_stage += 1; throbbler_stage %= 16; } } meter_finish(&meter); cleanup: meter_free(&meter); sc_close(&sc); if (err < 0) { return err; } return 0; }
static int rst_restore_iptables(struct cpt_context * ctx) { int err; int pfd[2]; struct file *f; struct cpt_object_hdr v; int n; struct cpt_section_hdr h; loff_t sec = ctx->sections[CPT_SECT_NET_IPTABLES]; loff_t end; int pid; int status; mm_segment_t oldfs; sigset_t ignore, blocked; if (sec == CPT_NULL) return 0; err = ctx->pread(&h, sizeof(h), ctx, sec); if (err) return err; if (h.cpt_section != CPT_SECT_NET_IPTABLES || h.cpt_hdrlen < sizeof(h)) return -EINVAL; if (h.cpt_hdrlen == h.cpt_next) return 0; if (h.cpt_hdrlen > h.cpt_next) return -EINVAL; sec += h.cpt_hdrlen; err = rst_get_object(CPT_OBJ_NAME, sec, &v, ctx); if (err < 0) return err; err = sc_pipe(pfd); if (err < 0) return err; ignore.sig[0] = CPT_SIG_IGNORE_MASK; sigprocmask(SIG_BLOCK, &ignore, &blocked); pid = err = local_kernel_thread(dumpfn, (void*)pfd, SIGCHLD, 0); if (err < 0) { eprintk_ctx("iptables local_kernel_thread: %d\n", err); goto out; } f = fget(pfd[1]); sc_close(pfd[1]); sc_close(pfd[0]); ctx->file->f_pos = sec + v.cpt_hdrlen; end = sec + v.cpt_next; do { char *p; char buf[16]; n = end - ctx->file->f_pos; if (n > sizeof(buf)) n = sizeof(buf); if (ctx->read(buf, n, ctx)) break; if ((p = memchr(buf, 0, n)) != NULL) n = p - buf; oldfs = get_fs(); set_fs(KERNEL_DS); f->f_op->write(f, buf, n, &f->f_pos); set_fs(oldfs); } while (ctx->file->f_pos < end); fput(f); oldfs = get_fs(); set_fs(KERNEL_DS); if ((err = sc_waitx(pid, 0, &status)) < 0) eprintk_ctx("wait4: %d\n", err); else if ((status & 0x7f) == 0) { err = (status & 0xff00) >> 8; if (err != 0) { eprintk_ctx("iptables-restore exited with %d\n", err); eprintk_ctx("Most probably some iptables modules are not loaded\n"); err = -EINVAL; } } else {
int main(int argc, char *argv[]) { setlocale(LC_ALL, ""); setvbuf(stdout, (char*)NULL, _IONBF, 0); if(argc != 4) { fprintf(stderr, MSG[I_HELP1], argv[0]); fputs(MSG[I_HELP2], stderr); return EXIT_FAILURE; } char *inname = argv[1], *outname = argv[2], *valarg = argv[3]; /* Quelldatei oeffnen und auf PNG-Signatur ueberpruefen **********************/ puts(MSG[I_OPEN]); FILE *f; f = fopen(inname, "rb"); if (f == NULL) { fputs(inname, stderr); fputs(MSG[E_OPEN], stderr); fputc('\n', stderr); return EXIT_FAILURE; } unsigned char sig[SIG_BYTES]; fread(sig, 1, SIG_BYTES, f); if (png_sig_cmp(sig, 0, SIG_BYTES)) { fputs(inname, stderr); fputs(MSG[E_CORRUPTED], stderr); fputc('\n', stderr); fclose(f); return EXIT_FAILURE; } /* PNG-Lesevorgang initialisieren *****************************************/ png_struct *png_ptr; png_info *info_ptr, *end_info; png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL ); if (png_ptr == NULL) { fputs(MSG[E_GENERIC], stderr); fputc('\n', stderr); fclose(f); return EXIT_FAILURE; } info_ptr = png_create_info_struct(png_ptr); end_info = png_create_info_struct(png_ptr); try_png_read( (info_ptr == NULL) || (end_info == NULL), &png_ptr, &info_ptr, &end_info, f, (char*)NULL ); try_png_read( setjmp(png_jmpbuf(png_ptr)), &png_ptr, &info_ptr, &end_info, f, MSG[E_READ] ); png_init_io(png_ptr, f); png_set_sig_bytes(png_ptr, SIG_BYTES); /* Bildinfo lesen: Bilddimensionen und ggf. Farbpalette. * Palette ggf. konvertieren. *********************************************/ long int width, height, pwidth, pheight; // png_uint_32 width, height, pwidth, pheight; comp_t *image, **row, *rwp; png_read_info(png_ptr, info_ptr); width = info_ptr->width; height = info_ptr->height; const long int original_width = info_ptr->width; const int bit_depth = info_ptr->bit_depth, color_type = info_ptr->color_type; const bool image_is_pal = (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE); const bool image_is_gray = ( (color_type == PNG_COLOR_TYPE_GRAY) || (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ); const bool alpha = ( (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) || (color_type == PNG_COLOR_TYPE_RGB_ALPHA) ); int num_palette = 0; png_color *png_pal_got = NULL; if (image_is_pal) try_png_read( !png_get_PLTE(png_ptr, info_ptr, &png_pal_got, &num_palette), &png_ptr, &info_ptr, &end_info, f, MSG[E_READPAL] ); png_color png_pal[num_palette]; comp_t comp_pal[num_palette]; if (image_is_pal) for (int i = 0; i < num_palette; i++) { png_pal[i] = png_pal_got[i]; comp_t c; c = png_pal[i].red; c <<= CHAR_BIT; c |= png_pal[i].green; c <<= CHAR_BIT; c |= png_pal[i].blue; comp_pal[i] = c; } png_color_16 *img_bkgd; png_color_16 background; if (png_get_bKGD(png_ptr, info_ptr, &img_bkgd)) background = *img_bkgd; /* Parameter fuer Groessenaenderung auswerten: * diff: (Seitenlaenge nachher) - (Seitenlaenge vorher), * vert: true <=> Aenderung der Bildhoehe (sonst -breite). ******************/ long int diff; bool vert; bool aspp = false, asp2 = false, enlg = false, sign = true; switch (tolower(*valarg++)) { case 'h': vert = false; break; case 'v': vert = true; break; case '%': aspp = true; break; case '@': asp2 = true; break; default : try_png_read(true, &png_ptr, &info_ptr, &end_info, f, MSG[E_DIM]); } switch (*valarg) { case '+': enlg = true; break; case '-': enlg = false; break; default: sign = false; break; } diff = atol(valarg); bool valargok = !!diff; if (aspp || asp2) { try_png_read(!sign, &png_ptr, &info_ptr, &end_info, f, MSG[E_SIGN]); const float fheight = (float)height, fwidth = (float)width, casp = fheight / fwidth; float nasp; if (asp2) { const char *aspsw = strtok(valarg, ":"), *aspsh = strtok((char*)NULL, ":"); valargok = ((aspsw != NULL) && (aspsh != NULL)); const float aspw = valargok? atol(aspsw): 0, asph = valargok? atol(aspsh): 0; nasp = valargok? fabs(asph / aspw): 0; } else nasp = ((float)labs(diff) / 100.0f); vert = ((nasp < casp) ^ enlg); diff = valargok? labs(vert? (height - (fwidth * nasp)): (width - (fheight / nasp)) ): 0; if (!enlg) diff = -diff; } if (!diff) { png_destroy_read_struct(&png_ptr, &info_ptr, &end_info); fclose(f); if (valargok) { puts(MSG[I_NOTHINGTODO]); // const char copycmd[] = "copy /b /y"; const char copycmd[] = "cp"; char copycmdln[ strlen(copycmd) + strlen(argv[1]) + strlen(argv[2]) + 7 ]; sprintf( copycmdln, "%s \"%s\" \"%s\"", copycmd, argv[1], argv[2] ); return system(copycmdln); } try_png_read(!valargok, &png_ptr, &info_ptr, &end_info, f, MSG[E_PAR]); } if (!(aspp || asp2 || sign)) diff -= vert? height: width; try_png_read( labs(diff) > (vert? height: width), &png_ptr, &info_ptr, &end_info, f, MSG[E_SIZE] ); /* Bild- sowie Zeilenzeigerspeicher anfordern und Zeiger setzen. **********/ image = malloc(width * height * sizeof(comp_t)); try_png_read(image == NULL, &png_ptr, &info_ptr, &end_info, f, (char*)NULL); row = malloc(height * sizeof(comp_t*)); try_png_read(row == NULL, &png_ptr, &info_ptr, &end_info, f, (char*)NULL); rwp = image; for (int i = 0; i < height; i++) { row[i] = rwp; rwp += width; } /* Bild laden. * Falls Alphakanal vorhanden, Alpha invertieren: hoher Wert => hohe Deckung. * Falls Nicht-Palettenbild ohne Alphakanal (24 bpp) oder Graubild * (8 oder 16 bpp), mit "png_set_filler" die Bilddaten auf 32 bzw. 16 bpp * ausweiten. 32 Bit ist die * comp_t-Breite. ****************************/ puts(MSG[I_LOAD]); if (alpha) png_set_invert_alpha(png_ptr); else if (!image_is_pal) png_set_filler(png_ptr, 0, PNG_FILLER_AFTER); png_read_image(png_ptr, (void*)row); /* Falls 8 oder 16 bpp, Bilddaten auf "Pixel = comp_t-Element" ausweiten. */ // trw: Temporaere Zeile. void *trw = malloc(image_is_gray? (width * 2): width); try_png_read(trw == NULL, &png_ptr, &info_ptr, &end_info, f, (char*)NULL); // Zunaechst Bildzeile nach Temporaerzeile kopieren, dann Elemente einzeln zurueck. if (image_is_pal) { for (int i = 0; i < height; i++) { uint8_t *trwp = trw; rwp = row[i]; memcpy(trw, row[i], width * sizeof *trwp); for (int j = 0; j < width; j++) *rwp++ = *trwp++; } } if (image_is_gray) { for (int i = 0; i < height; i++) { uint16_t *trwp = trw; rwp = row[i]; memcpy(trw, row[i], width * sizeof *trwp); for (int j = 0; j < width; j++) *rwp++ = *trwp++; } } /* Lesevorgang beenden und Quelldatei schliessen. ************************/ png_destroy_read_struct(&png_ptr, &info_ptr, &end_info); fclose(f); printf( "%s: %d*%d > %d*%d: %s %+d\n", MSG[I_MEASURES], width, height, vert? width: width + diff, vert? height + diff: height, vert? MSG[I_VERT]: MSG[I_HORI], diff ); /* Hier kommt Fugenschnitzer zum Einsatz. * diff: (Seitenlaenge nachher) - (Seitenlaenge vorher), * vert: true <=> Aenderung der Bildhoehe (sonst -breite). ****************/ sc_init(); sc_load(image, &width, &height, 0); const int prep = sc_prepare( vert, diff, // Bild ggf. erweitern false, alpha? MARK_ALPHA: MARK_KEEP, // Ggf. Alpha-Markierung (mark_t*)NULL, // keine Markierung sonst &width, &height, &pwidth, &pheight ); if (prep < 0) { fputs(MSG[E_GENERIC], stderr); fputc('\n', stderr); free(image); free(row); return EXIT_FAILURE; } if (prep & 2) puts(MSG[E_ALPHA]); // Bildspeicher erweitern, falls das Bild vergroessert wurde: if (prep & 1) { image = realloc(image, (size_t)width * (size_t)height * sizeof(comp_t)); if (image == NULL) { fputs(MSG[E_GENERIC], stderr); fputc('\n', stderr); return EXIT_FAILURE; } if (vert) { row = realloc(row, (size_t)height * sizeof(comp_t*)); if (row == NULL) { fputs(MSG[E_GENERIC], stderr); fputc('\n', stderr); free(image); return EXIT_FAILURE; } } } pthread_t seam_th; pthread_create(&seam_th, NULL, seam_progress, (void*)(&diff)); // sc_seam(diff); seam_paral(diff); pthread_join(seam_th, NULL); putchar('\n'); printf(MSG[I_RESIZING]); // sc_carve(diff, &width, &height, &pwidth, &pheight); carve_paral(diff, &width, &height, &pwidth, &pheight); sc_fix( false, // Nicht wiederherstellen &width, &height, &pwidth, &pheight ); sc_eject(image); sc_close(); /* Das war's mit Fugenschnitzer. -- Zeilenzeiger neu setzen. **************/ rwp = image; for (int i = 0; i < height; i++) { row[i] = rwp; rwp += width; } /* Zieldatei oeffnen und Schreibvorgang initialisieren. ********************/ putchar('\n'); printf(MSG[I_SAVE]); f = fopen(outname, "wb"); if (f == NULL) { fputs(outname, stderr); fputs(MSG[E_SAVE], stderr); fputc('\n', stderr); return EXIT_FAILURE; } png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL ); if (png_ptr == NULL) { fputs(MSG[E_GENERIC], stderr); fputc('\n', stderr); fclose(f); return EXIT_FAILURE; } info_ptr = png_create_info_struct(png_ptr); try_png_write(info_ptr == NULL, &png_ptr, &info_ptr, f, (char*)NULL); try_png_write( setjmp(png_jmpbuf(png_ptr)), &png_ptr, &info_ptr, f, MSG[E_WRITE] ); png_init_io(png_ptr, f); /* Bildparameter setzen. **************************************************/ png_set_IHDR( png_ptr, info_ptr, width, height, bit_depth, color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT ); if (image_is_pal) png_set_PLTE(png_ptr, info_ptr, png_pal, num_palette); if (alpha) png_set_bKGD(png_ptr, info_ptr, &background); png_write_info(png_ptr, info_ptr); /* Falls 8 oder 16 bpp, Bilddaten wieder zusammenschieben. ****************/ trw = realloc(trw, image_is_gray? (width * 2): width); try_png_write(trw == NULL, &png_ptr, &info_ptr, f, (char*)NULL); if (image_is_pal) { for (int i = 0; i < height; i++) { uint8_t *trwp = trw; rwp = row[i]; for (int j = 0; j < width; j++) *trwp++ = *rwp++; memcpy(row[i], trw, width * sizeof *trwp); } } if (image_is_gray) { for (int i = 0; i < height; i++) { uint16_t *trwp = trw; rwp = row[i]; for (int j = 0; j < width; j++) *trwp++ = *rwp++; memcpy(row[i], trw, width * sizeof *trwp); } } /* Bild speichern. Wieder Alpha invertieren (hoher Wert => hohe Transparenz) * sowie mit "png_set_filler" 32/16 bpp => 24/8 bpp setzen. ***************/ if (alpha) png_set_invert_alpha(png_ptr); else png_set_filler(png_ptr, 0, PNG_FILLER_AFTER); png_write_image(png_ptr, (void*)row); png_write_end(png_ptr, (png_info*)NULL); puts(MSG[I_FINISHED]); /* Schreibvorgang beenden, Datei schliessen, Speicher freigeben, fertig. ***/ png_destroy_write_struct(&png_ptr, &info_ptr); fclose(f); free(trw); free(image); free(row); puts(MSG[I_COMPLETED]); return EXIT_SUCCESS; }
static void quit() { sc_close(); }
static int sc_prkey_op_init(RSA *rsa, struct sc_pkcs15_object **key_obj_out, unsigned int usage) { int r; struct sc_priv_data *priv; struct sc_pkcs15_object *key_obj; struct sc_pkcs15_prkey_info *key; struct sc_pkcs15_object *pin_obj; struct sc_pkcs15_pin_info *pin; priv = (struct sc_priv_data *) RSA_get_app_data(rsa); if (priv == NULL) return -1; if (p15card == NULL) { sc_close(); r = sc_init(); if (r) { error("SmartCard init failed: %s", sc_strerror(r)); goto err; } } r = sc_pkcs15_find_prkey_by_id_usage(p15card, &priv->cert_id, usage, &key_obj); if (r) { error("Unable to find private key from SmartCard: %s", sc_strerror(r)); goto err; } key = key_obj->data; r = sc_pkcs15_find_pin_by_auth_id(p15card, &key_obj->auth_id, &pin_obj); if (r == SC_ERROR_OBJECT_NOT_FOUND) { /* no pin required */ r = sc_lock(card); if (r) { error("Unable to lock smartcard: %s", sc_strerror(r)); goto err; } *key_obj_out = key_obj; return 0; } else if (r) { error("Unable to find PIN object from SmartCard: %s", sc_strerror(r)); goto err; } pin = pin_obj->data; r = sc_lock(card); if (r) { error("Unable to lock smartcard: %s", sc_strerror(r)); goto err; } if (sc_pin != NULL) { r = sc_pkcs15_verify_pin(p15card, pin, sc_pin, strlen(sc_pin)); if (r) { sc_unlock(card); error("PIN code verification failed: %s", sc_strerror(r)); goto err; } } *key_obj_out = key_obj; return 0; err: sc_close(); return -1; }
static int sc_read_pubkey(Key * k) { u_char buf[2], *n; char *p; int len, sw, status = -1; len = sw = 0; n = NULL; if (sc_fd < 0) { if (sc_init() < 0) goto err; } /* get key size */ sectok_apdu(sc_fd, CLA_SSH, INS_GET_KEYLENGTH, 0, 0, 0, NULL, sizeof(buf), buf, &sw); if (!sectok_swOK(sw)) { error("could not obtain key length: %s", sectok_get_sw(sw)); goto err; } len = (buf[0] << 8) | buf[1]; len /= 8; debug("INS_GET_KEYLENGTH: len %d sw %s", len, sectok_get_sw(sw)); n = xmalloc(len); /* get n */ sectok_apdu(sc_fd, CLA_SSH, INS_GET_PUBKEY, 0, 0, 0, NULL, len, n, &sw); if (sw == 0x6982) { if (try_AUT0() < 0) goto err; sectok_apdu(sc_fd, CLA_SSH, INS_GET_PUBKEY, 0, 0, 0, NULL, len, n, &sw); } if (!sectok_swOK(sw)) { error("could not obtain public key: %s", sectok_get_sw(sw)); goto err; } debug("INS_GET_KEYLENGTH: sw %s", sectok_get_sw(sw)); if (BN_bin2bn(n, len, k->rsa->n) == NULL) { error("c_read_pubkey: BN_bin2bn failed"); goto err; } /* currently the java applet just stores 'n' */ if (!BN_set_word(k->rsa->e, 35)) { error("c_read_pubkey: BN_set_word(e, 35) failed"); goto err; } status = 0; p = key_fingerprint(k, SSH_FP_MD5, SSH_FP_HEX); debug("fingerprint %u %s", key_size(k), p); xfree(p); err: if (n != NULL) xfree(n); sc_close(); return status; }