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;
}