static int ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s) { static const char module[] = "ZIPDecode"; ZIPState* sp = DecoderState(tif); (void) s; assert(sp != NULL); assert(sp->state == ZSTATE_INIT_DECODE); sp->stream.next_in = tif->tif_rawcp; sp->stream.avail_in = (uInt) tif->tif_rawcc; sp->stream.next_out = op; assert(sizeof(sp->stream.avail_out)==4); /* if this assert gets raised, we need to simplify this code to reflect a ZLib that is likely updated to deal with 8byte memory sizes, though this code will respond appropriately even before we simplify it */ sp->stream.avail_out = (uInt) occ; if ((tmsize_t)sp->stream.avail_out != occ) { TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size"); return (0); } do { int state = inflate(&sp->stream, Z_PARTIAL_FLUSH); if (state == Z_STREAM_END) break; if (state == Z_DATA_ERROR) { TIFFErrorExt(tif->tif_clientdata, module, "Decoding error at scanline %lu, %s", (unsigned long) tif->tif_row, SAFE_MSG(sp)); if (inflateSync(&sp->stream) != Z_OK) return (0); continue; } if (state != Z_OK) { TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s", SAFE_MSG(sp)); return (0); } } while (sp->stream.avail_out > 0); if (sp->stream.avail_out != 0) { TIFFErrorExt(tif->tif_clientdata, module, "Not enough data at scanline %lu (short " TIFF_UINT64_FORMAT " bytes)", (unsigned long) tif->tif_row, (TIFF_UINT64_T) sp->stream.avail_out); return (0); } tif->tif_rawcp = sp->stream.next_in; tif->tif_rawcc = sp->stream.avail_in; return (1); }
/* * Finish off an encoded strip by flushing the last * string and tacking on an End Of Information code. */ static int ZIPPostEncode(TIFF* tif) { static const char module[] = "ZIPPostEncode"; ZIPState *sp = EncoderState(tif); int state; sp->stream.avail_in = 0; do { state = deflate(&sp->stream, Z_FINISH); switch (state) { case Z_STREAM_END: case Z_OK: if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) { tif->tif_rawcc = tif->tif_rawdatasize - sp->stream.avail_out; TIFFFlushData1(tif); sp->stream.next_out = tif->tif_rawdata; sp->stream.avail_out = (uInt) tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in ZIPPreEncode */ } break; default: TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s", SAFE_MSG(sp)); return (0); } } while (state != Z_STREAM_END); return (1); }
static int ZIPSetupDecode(TIFF* tif) { static const char module[] = "ZIPSetupDecode"; ZIPState* sp = DecoderState(tif); assert(sp != NULL); /* if we were last encoding, terminate this mode */ if (sp->state & ZSTATE_INIT_ENCODE) { deflateEnd(&sp->stream); sp->state = 0; } /* This function can possibly be called several times by */ /* PredictorSetupDecode() if this function succeeds but */ /* PredictorSetup() fails */ if ((sp->state & ZSTATE_INIT_DECODE) == 0 && inflateInit(&sp->stream) != Z_OK) { TIFFErrorExt(tif->tif_clientdata, module, "%s", SAFE_MSG(sp)); return (0); } else { sp->state |= ZSTATE_INIT_DECODE; return (1); } }
static int ZIPSetupEncode(TIFF* tif) { static const char module[] = "ZIPSetupEncode"; ZIPState* sp = EncoderState(tif); assert(sp != NULL); if (sp->state & ZSTATE_INIT_DECODE) { inflateEnd(&sp->stream); sp->state = 0; } if (deflateInit(&sp->stream, sp->zipquality) != Z_OK) { TIFFErrorExt(tif->tif_clientdata, module, "%s", SAFE_MSG(sp)); return (0); } else { sp->state |= ZSTATE_INIT_ENCODE; return (1); } }
static int ZIPSetupDecode(TIFF* tif) { static const char module[] = "ZIPSetupDecode"; ZIPState* sp = DecoderState(tif); assert(sp != NULL); /* if we were last encoding, terminate this mode */ if (sp->state & ZSTATE_INIT_ENCODE) { deflateEnd(&sp->stream); sp->state = 0; } if (inflateInit(&sp->stream) != Z_OK) { TIFFErrorExt(tif->tif_clientdata, module, "%s", SAFE_MSG(sp)); return (0); } else { sp->state |= ZSTATE_INIT_DECODE; return (1); } }
static int ZIPVSetField(TIFF* tif, uint32 tag, va_list ap) { static const char module[] = "ZIPVSetField"; ZIPState* sp = ZState(tif); switch (tag) { case TIFFTAG_ZIPQUALITY: sp->zipquality = (int) va_arg(ap, int); if ( sp->state&ZSTATE_INIT_ENCODE ) { if (deflateParams(&sp->stream, sp->zipquality, Z_DEFAULT_STRATEGY) != Z_OK) { TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s", SAFE_MSG(sp)); return (0); } } return (1); default: return (*sp->vsetparent)(tif, tag, ap); } /*NOTREACHED*/ }
/* * Encode a chunk of pixels. */ static int ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { static const char module[] = "ZIPEncode"; ZIPState *sp = EncoderState(tif); assert(sp != NULL); assert(sp->state == ZSTATE_INIT_ENCODE); (void) s; sp->stream.next_in = bp; assert(sizeof(sp->stream.avail_in)==4); /* if this assert gets raised, we need to simplify this code to reflect a ZLib that is likely updated to deal with 8byte memory sizes, though this code will respond appropriately even before we simplify it */ sp->stream.avail_in = (uInt) cc; if ((tmsize_t)sp->stream.avail_in != cc) { TIFFErrorExt(tif->tif_clientdata, module, "ZLib cannot deal with buffers this size"); return (0); } do { if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) { TIFFErrorExt(tif->tif_clientdata, module, "Encoder error: %s", SAFE_MSG(sp)); return (0); } if (sp->stream.avail_out == 0) { tif->tif_rawcc = tif->tif_rawdatasize; TIFFFlushData1(tif); sp->stream.next_out = tif->tif_rawdata; sp->stream.avail_out = (uInt) tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in ZIPPreEncode */ } } while (sp->stream.avail_in > 0); return (1); }
int run_gdb(unsigned dbg_flags, const char *dbg_opts) { // Note that this function and it's callee's should be signal-safe. // Strlen and sprintf are not officially signal-safe but come on... // Check if gdb is already attached if(gdb_pid != -1) { int status = 0; pid_t res_pid = waitpid(gdb_pid, &status, WNOHANG); if(res_pid == -1) { SAFE_MSG("libdebugme: failed to check status of debugger\n"); return 0; } else if(res_pid == 0 || (res_pid == gdb_pid && !WIFEXITED(status) && !WIFSIGNALED(status))) { SAFE_MSG("libdebugme: can't attach more than one debugger simultaneously\n"); return 0; } gdb_pid = -1; } gdb_pid = fork(); switch(gdb_pid) { case -1: SAFE_MSG("libdebugme: failed to fork\n"); return 0; case 0: { // Child pid_t ppid = getppid(); char buf[256]; int nread = snprintf(buf, sizeof(buf), "gdb -ex 'attach %ld' " // Unblock parent process "-ex 'set __debugme_go=1' " // Wait untils it breaks "-ex continue " // Return from raise() "-ex finish " // Give control to user "%s", (long)ppid, dbg_opts); if(nread >= (int)sizeof(buf) - 1) { SAFE_MSG("libdebugme: increase size of buffer in run_gdb\n"); exit(1); } if(dbg_flags & DEBUGME_XTERM) { execl("/usr/bin/xterm", "/usr/bin/xterm", "-e", buf, (char *)0); } else { execl("/bin/bash", "/bin/bash", "-c", buf, (char *)0); } SAFE_MSG("libdebugme: failed to run gdb command: /bin/bash -c "); SAFE_MSG(buf); SAFE_MSG("\n"); _exit(1); } } // Parent return 1; }