/* ---------------------------------------------------------------------- */
void check_args() {
/* check if filled elevation grid name is valid */
if (G_legal_filename (opt->filled_grid) < 0) {
G_fatal_error(_("<%s> is an illegal file name"), opt->filled_grid);
}
/* check if output grid names are valid */
if (G_legal_filename (opt->dir_grid) < 0) {
G_fatal_error(_("<%s> is an illegal file name"), opt->dir_grid);
}
if (G_legal_filename (opt->filled_grid) < 0) {
G_fatal_error(_("<%s> is an illegal file name"), opt->filled_grid);
}
if (G_legal_filename (opt->flowaccu_grid) < 0) {
G_fatal_error(_("<%s> is an illegal file name"), opt->flowaccu_grid);
}
if (G_legal_filename (opt->watershed_grid) < 0) {
G_fatal_error(_("<%s> is an illegal file name"), opt->watershed_grid);
}
#ifdef OUTPU_TCI
if (G_legal_filename (opt->tci_grid) < 0) {
G_fatal_error(_("<%s> is an illegal file name"), opt->tci_grid);
}
#endif
/* check compatibility with region */
check_header(opt->elev_grid);
/* what else ? */
}
int
copen(const char *fname, int mode)
{
int fd;
struct sd *s = 0;
if ( ((fd = open(fname, mode)) == -1) || (mode != O_RDONLY) )
/* compression only for read */
return(fd);
ss[fd] = s = malloc(sizeof(struct sd));
if (s == 0)
goto errout;
memset(s, 0, sizeof(struct sd));
if (inflateInit2(&(s->stream), -15) != Z_OK)
goto errout;
s->stream.next_in = s->inbuf = (unsigned char*)malloc(Z_BUFSIZE);
if (s->inbuf == 0) {
inflateEnd(&(s->stream));
goto errout;
}
s->fd = fd;
check_header(s); /* skip the .gz header */
return(fd);
errout:
if (s != 0)
free(s);
close(fd);
return (-1);
}
static void flush_inbody_header_accum(struct mailinfo *mi)
{
if (!mi->inbody_header_accum.len)
return;
assert(check_header(mi, &mi->inbody_header_accum, mi->s_hdr_data, 0));
strbuf_reset(&mi->inbody_header_accum);
}
static int l_dissect_udp(lua_State *L)
{
header_t *header = NULL;
udp_t *udp = NULL;
header = check_header(L, 1);
udp = (udp_t *)header->data;
lua_newtable(L);
lua_pushstring(L, "src_port");
lua_pushnumber(L, ntohs(udp->src_port));
lua_settable(L, -3);
lua_pushstring(L, "dst_port");
lua_pushnumber(L, ntohs(udp->dest_port));
lua_settable(L, -3);
lua_pushstring(L, "payload_len");
lua_pushnumber(L, ntohs(udp->len));
lua_settable(L, -3);
lua_pushstring(L, "cksum");
lua_pushnumber(L, ntohs(udp->checksum));
lua_settable(L, -3);
se_setro(L);
return 1;
}
void dir_test()
{
ar::tar::header head;
head.format = ar::tar::pax;
head.type_flag = ar::tar::type_flag::directory;
head.path = "dir";
head.modified_time = fs_ex::timestamp(std::time(0), 123456789);
head.access_time = fs_ex::timestamp(1, 123456789);
head.change_time = fs_ex::timestamp(12345, 0);
head.file_size = 0;
head.permissions = 0123;
head.comment = "test comment";
io_ex::tmp_file archive;
ar::basic_tar_file_sink<
io_ex::dont_close_device<io_ex::tmp_file>
> sink(io_ex::dont_close(archive));
sink.create_entry(head);
sink.close();
sink.close_archive();
io::seek(archive, 0, BOOST_IOS::beg);
ar::basic_tar_file_source<io_ex::tmp_file> src(archive);
BOOST_CHECK(src.next_entry());
check_header(head, src.header());
BOOST_CHECK(!src.next_entry());
}
static struct cw_filestream *au_open(FILE *f)
{
struct cw_filestream *tmp;
if (!(tmp = malloc(sizeof(struct cw_filestream))))
{
cw_log(LOG_ERROR, "Out of memory\n");
return NULL;
}
memset(tmp, 0, sizeof(struct cw_filestream));
if (check_header(f) < 0)
{
free(tmp);
return NULL;
}
if (cw_mutex_lock(&au_lock))
{
cw_log(LOG_WARNING, "Unable to lock au count\n");
free(tmp);
return NULL;
}
tmp->f = f;
cw_fr_init_ex(&tmp->fr, CW_FRAME_VOICE, CW_FORMAT_ULAW, NULL);
tmp->fr.data = tmp->buf;
/* datalen will vary for each frame */
tmp->fr.src = name;
localusecnt++;
cw_mutex_unlock(&au_lock);
cw_update_use_count();
return tmp;
}
int eapi_load(easyflash_cart_t * cart, const char* filename)
{
unsigned char buf[EAPI_SIZE + 2];
unsigned int load_addr = 0;
util_message("Loading EAPI '%s'...", filename);
if (util_prgfile_load(filename, buf, EAPI_SIZE, 0, &load_addr) < 0) {
return -1;
}
if (load_addr != EAPI_FILE_LOAD_ADDR) {
util_error("load address $%04x, expecting $%04x!", load_addr, EAPI_FILE_LOAD_ADDR);
return -1;
}
if (check_header(buf) != 0) {
util_error("file '%s' doesn't have EAPI header!", filename);
return -1;
}
memcpy(eapi_data, buf, EAPI_SIZE);
cart->main_flash_state |= MAIN_STATE_HAVE_EAPI;
return 0;
}
/* Try to load a savefile */
static bool try_load(ang_file *f, const struct blockinfo *loaders) {
struct blockheader b;
errr err;
if (!check_header(f)) {
note("Savefile is corrupted -- incorrect file header.");
return FALSE;
}
/* Get the next block header */
while ((err = next_blockheader(f, &b)) == 0) {
loader_t loader = find_loader(&b, loaders);
if (!loader) {
note("Savefile block can't be read.");
note("Maybe try and load the savefile in an earlier version of Angband.");
return FALSE;
}
if (!load_block(f, &b, loader)) {
note(format("Savefile corrupted - Couldn't load block %s", b.name));
return FALSE;
}
}
if (err == -1) {
note("Savefile is corrupted -- block header mangled.");
return FALSE;
}
/* XXX Reset cause of death */
if (p_ptr->chp >= 0)
my_strcpy(p_ptr->died_from, "(alive and well)", sizeof(p_ptr->died_from));
return TRUE;
}
static gboolean
init_zip (GsfInputGZip *gzip, GError **err)
{
gsf_off_t cur_pos;
if (Z_OK != inflateInit2 (&(gzip->stream), -MAX_WBITS)) {
if (err != NULL)
*err = g_error_new (gsf_input_error_id (), 0,
"Unable to initialize zlib");
return TRUE;
}
cur_pos = gsf_input_tell (gzip->source);
if (gsf_input_seek (gzip->source, 0, G_SEEK_SET)) {
if (err)
*err = g_error_new (gsf_input_error_id (), 0,
"Failed to rewind source");
return TRUE;
}
if (check_header (gzip) != FALSE) {
if (err != NULL)
*err = g_error_new (gsf_input_error_id (), 0,
"Invalid gzip header");
if (gsf_input_seek (gzip->source, cur_pos, G_SEEK_SET)) {
g_warning ("attempt to restore position failed ??");
}
return TRUE;
}
return FALSE;
}
void unicode_test()
{
ar::lha::wheader head;
head.level = 2;
head.update_time = std::time(0);
head.attributes = ar::msdos::attributes::read_only;
head.path = L"\x3053\x3093\x306B\x3061\x306F/\x4F60\x597D.txt";
head.os = 'M';
io_ex::tmp_file archive;
ar::basic_lzh_file_sink<
io_ex::dont_close_device<io_ex::tmp_file>,
fs::wpath
> sink(io_ex::dont_close(archive));
sink.create_entry(head);
sink.close();
sink.close_archive();
io::seek(archive, 0, BOOST_IOS::beg);
ar::basic_lzh_file_source<io_ex::tmp_file,fs::wpath> src(archive);
BOOST_CHECK(src.next_entry());
check_header(head, src.header());
BOOST_CHECK(!src.next_entry());
}
static int handle_commit_msg(char *line, unsigned linesize)
{
static int still_looking = 1;
char *endline = line + linesize;
if (!cmitmsg)
return 0;
if (still_looking) {
char *cp = line;
if (isspace(*line)) {
for (cp = line + 1; *cp; cp++) {
if (!isspace(*cp))
break;
}
if (!*cp)
return 0;
}
if ((still_looking = check_header(cp, endline - cp, s_hdr_data, 0)) != 0)
return 0;
}
/* normalize the log message to UTF-8. */
if (metainfo_charset)
convert_to_utf8(line, endline - line, charset);
if (patchbreak(line)) {
fclose(cmitmsg);
cmitmsg = NULL;
return 1;
}
fputs(line, cmitmsg);
return 0;
}
static int remote_read(apacket *p, atransport *t)
{
if(usb_read(t->usb, &p->msg, sizeof(amessage))){
D("remote usb: read terminated (message)\n");
return -1;
}
fix_endians(p);
if(check_header(p)) {
D("remote usb: check_header failed\n");
return -1;
}
if(p->msg.data_length) {
if(usb_read(t->usb, p->data, p->msg.data_length)){
D("remote usb: terminated (data)\n");
return -1;
}
}
if(check_data(p)) {
D("remote usb: check_data failed\n");
return -1;
}
return 0;
}
int
basic_parser::do_header_field (char const* in, std::size_t bytes)
{
check_header();
field_.append (static_cast <char const*> (in), bytes);
return 0;
}
int ns__echoString(struct soap *soap, char *str, char **res)
{ /* Get Header info and setup response Header */
if (check_header(soap))
{ printf("Malformed header\n");
return SOAP_FAULT; /* there was a problem */
}
/* If message with MessageID already received, ignore it */
if (check_received(soap->header->wsa__MessageID))
{ printf("Request message %s already received\n", soap->header->wsa__MessageID);
return SOAP_STOP;
}
printf("Request message %s accepted\n", soap->header->wsa__MessageID);
/* Check ReplyTo has Address */
if (!soap->header->wsa__ReplyTo || !soap->header->wsa__ReplyTo->Address)
return soap_sender_fault(soap, "No WS-Addressing ReplyTo address", NULL);
/* Copy Header info into response Header */
soap->header->wsa__To = soap->header->wsa__ReplyTo->Address;
/* Add info to response Header */
soap->header->wsa__MessageID = soap_strdup(soap, soap_int2s(soap, id_count++));
soap->header->wsa__Action = "http://genivia.com/udp/echoStringResponse";
/* Copy request string into response string */
printf("Response message %s returned\n", soap->header->wsa__MessageID);
*res = str;
return SOAP_OK;
}
static int remote_read(apacket *p, atransport *t)
{
if(readx(t->sfd, &p->msg, sizeof(amessage))){
D("remote local: read terminated (message)\n");
return -1;
}
fix_endians(p);
#if 0 && defined __ppc__
D("read remote packet: %04x arg0=%0x arg1=%0x data_length=%0x data_check=%0x magic=%0x\n",
p->msg.command, p->msg.arg0, p->msg.arg1, p->msg.data_length, p->msg.data_check, p->msg.magic);
#endif
if(check_header(p)) {
D("bad header: terminated (data)\n");
return -1;
}
if(readx(t->sfd, p->data, p->msg.data_length)){
D("remote local: terminated (data)\n");
return -1;
}
if(check_data(p)) {
D("bad data: terminated (data)\n");
return -1;
}
return 0;
}
static void *check_data(u8 *buf, size_t bsize, u32 *swap)
{
u32 word, p = 0; /* possition */
/* Because buf doesn't need to be aligned let's read it by chars */
for (p = 0; p < bsize; p++) {
word = load_word(&buf[p], SWAP_NO);
debug("%s: word %x %x/%x\n", __func__, word, p, (u32)&buf[p]);
/* Find the first bitstream dummy word */
if (word == DUMMY_WORD) {
debug("%s: Found dummy word at position %x/%x\n",
__func__, p, (u32)&buf[p]);
*swap = check_header(&buf[p]);
if (*swap) {
/* FIXME add full bitstream checking here */
return &buf[p];
}
}
/* Loop can be huge - support CTRL + C */
if (ctrlc())
return 0;
}
return 0;
}
void
BestEffortSession::record_header_received(const TransportHeader& header)
{
if (this->remote_peer_ != header.source_) return;
check_header(header);
}
/**
* Try to get the 'description' block from a savefile. Fail gracefully.
*/
const char *savefile_get_description(const char *path) {
struct blockheader b;
ang_file *f = file_open(path, MODE_READ, FTYPE_TEXT);
if (!f) return NULL;
/* Blank the description */
savefile_desc[0] = 0;
if (!check_header(f)) {
my_strcpy(savefile_desc, "Invalid savefile", sizeof savefile_desc);
} else {
while (!next_blockheader(f, &b)) {
if (!streq(b.name, "description")) {
skip_block(f, &b);
continue;
}
load_block(f, &b, get_desc);
break;
}
}
file_close(f);
return savefile_desc;
}
/*
* @brief Decrypt an attribute value.
*
* Returns a decrypted copy of the value, the original value is left intact.
*
* @param err Pointer to an error code, set to:
* LDB_SUCESS If the value was successfully decrypted
* LDB_ERR_OPERATIONS_ERROR If there was an error.
*
* @param ctx Talloc memory context the will own the memory allocated
* @param ldb ldb context, to allow logging.
* @param val The ldb value to decrypt, not altered or freed
* @param data The context data for this module.
*
* @return The decrypted ldb_val, or data_blob_null if there was an error.
*/
static struct ldb_val decrypt_value(int *err,
TALLOC_CTX *ctx,
struct ldb_context *ldb,
const struct ldb_val val,
const struct es_data *data)
{
struct ldb_val dec;
struct EncryptedSecret es;
struct PlaintextSecret ps = { data_blob_null};
int rc;
TALLOC_CTX *frame = talloc_stackframe();
rc = ndr_pull_struct_blob(&val,
frame,
&es,
(ndr_pull_flags_fn_t)
ndr_pull_EncryptedSecret);
if(!NDR_ERR_CODE_IS_SUCCESS(rc)) {
ldb_asprintf_errstring(ldb,
"Error(%d) unpacking encrypted secret, "
"data possibly corrupted or altered\n",
rc);
*err = LDB_ERR_OPERATIONS_ERROR;
TALLOC_FREE(frame);
return data_blob_null;
}
if (!check_header(&es)) {
/*
* Header is invalid so can't be an encrypted value
*/
ldb_set_errstring(ldb, "Invalid EncryptedSecrets header\n");
*err = LDB_ERR_OPERATIONS_ERROR;
return data_blob_null;
}
#ifdef BUILD_WITH_GNUTLS_AEAD
gnutls_decrypt_aead(err, frame, ldb, &es, &ps, data);
#elif defined BUILD_WITH_SAMBA_AES_GCM
samba_decrypt_aead(err, frame, ldb, &es, &ps, data);
#endif
if (*err != LDB_SUCCESS) {
TALLOC_FREE(frame);
return data_blob_null;
}
dec = data_blob_talloc(ctx,
ps.cleartext.data,
ps.cleartext.length);
if (dec.data == NULL) {
TALLOC_FREE(frame);
ldb_set_errstring(ldb, "Out of memory, copying value\n");
*err = LDB_ERR_OPERATIONS_ERROR;
return data_blob_null;
}
TALLOC_FREE(frame);
return dec;
}
static struct ast_filestream *wav_open(int fd)
{
/* We don't have any header to read or anything really, but
if we did, it would go here. We also might want to check
and be sure it's a valid file. */
struct ast_filestream *tmp;
if ((tmp = malloc(sizeof(struct ast_filestream)))) {
memset(tmp, 0, sizeof(struct ast_filestream));
if (check_header(fd)) {
free(tmp);
return NULL;
}
if (ast_mutex_lock(&wav_lock)) {
ast_log(LOG_WARNING, "Unable to lock wav list\n");
free(tmp);
return NULL;
}
tmp->fd = fd;
tmp->fr.data = tmp->gsm;
tmp->fr.frametype = AST_FRAME_VOICE;
tmp->fr.subclass = AST_FORMAT_GSM;
/* datalen will vary for each frame */
tmp->fr.src = name;
tmp->fr.mallocd = 0;
tmp->secondhalf = 0;
glistcnt++;
ast_mutex_unlock(&wav_lock);
ast_update_use_count();
}
return tmp;
}
static int l_header_dissect(lua_State *L)
{
proto_t * p = NULL;
header_t *h = check_header(L, -1);
p = proto_get_byname(h->proto);
myassert(p != NULL);
if (p->dissect == NULL) {
lua_pushnil(L);
return 1;
}
/* Stack pos 2: traceback function */
lua_getfield(L, LUA_REGISTRYINDEX, SE_TRACEBACK);
/* Stack pos 3: dissect callback function */
lua_pushcfunction(L, p->dissect);
/* Stack pos 4: header userdata */
lua_pushvalue(L, 1);
if (lua_pcall(L, 1, 1, 2) != 0) {
lua_error(L);
return 0;
}
return 1;
}
void symlink_test_aux(const fs::path& link, const fs::path& target, bool dir)
{
ar::lha::header head;
head.level = 0;
head.update_time = std::time(0);
head.attributes = ar::msdos::attributes::hidden;
if (dir)
head.attributes |= ar::msdos::attributes::directory;
head.path = link;
head.link_path = target;
io_ex::tmp_file archive;
ar::basic_lzh_file_sink<
io_ex::dont_close_device<io_ex::tmp_file>
> sink(io_ex::dont_close(archive));
sink.create_entry(head);
sink.close();
sink.close_archive();
io::seek(archive, 0, BOOST_IOS::beg);
ar::basic_lzh_file_source<io_ex::tmp_file> src(archive);
BOOST_CHECK(src.next_entry());
check_header(head, src.header());
BOOST_CHECK(!src.next_entry());
}
void abs_path_test()
{
ar::lha::header head;
head.level = 0;
head.update_time = std::time(0);
head.attributes = ar::msdos::attributes::directory;
head.path = "/dir/file";
head.os = '?';
io_ex::tmp_file archive;
ar::basic_lzh_file_sink<
io_ex::dont_close_device<io_ex::tmp_file>
> sink(io_ex::dont_close(archive));
sink.create_entry(head);
sink.close_archive();
io::seek(archive, 0, BOOST_IOS::beg);
ar::basic_lzh_file_source<io_ex::tmp_file> src(archive);
BOOST_CHECK(src.next_entry());
check_header(head, src.header());
BOOST_CHECK(!src.next_entry());
}
static int mailinfo(FILE *in, FILE *out, const char *msg, const char *patch)
{
int peek;
fin = in;
fout = out;
cmitmsg = fopen(msg, "w");
if (!cmitmsg) {
perror(msg);
return -1;
}
patchfile = fopen(patch, "w");
if (!patchfile) {
perror(patch);
fclose(cmitmsg);
return -1;
}
p_hdr_data = xcalloc(MAX_HDR_PARSED, sizeof(*p_hdr_data));
s_hdr_data = xcalloc(MAX_HDR_PARSED, sizeof(*s_hdr_data));
do {
peek = fgetc(in);
} while (isspace(peek));
ungetc(peek, in);
/* process the email header */
while (read_one_header_line(&line, fin))
check_header(&line, p_hdr_data, 1);
handle_body();
handle_info();
return 0;
}
static int
check_and_write_header(int fd, int type, int readonly)
{
file_header_t header;
ssize_t bytes;
char* s;
assert(-1 != fd && ('d' == type || 'i' == type));
s = 'd' == type ? "data" : "index";
memset(&header, 0, sizeof(header));
bytes = readn(fd, &header, sizeof(header));
if (bytes != sizeof(header)) {
ERRORV(readonly || bytes != 0, "Incomplete %s file header", s);
if (! readonly) {
ERRORVP(0 != write_header(fd, type),
"Can't write %s file header", s);
}
} else {
ERRORV(0 != check_header(&header, type), "Corrupted %s file", s);
}
return 0;
L_error:
return -1;
}
static inline int verify_table(const void *buf, uoffset_t end, uoffset_t base, uoffset_t offset, int ttl, flatcc_table_verifier_f tvf)
{
uoffset_t vbase, vend;
flatcc_table_verifier_descriptor_t td;
verify((td.ttl = ttl - 1), flatcc_verify_error_max_nesting_level_reached);
verify(check_header(end, base, offset), flatcc_verify_error_table_header_out_of_range_or_unaligned);
td.table = base + offset;
/* Read vtable offset - it is signed, but we want it unsigned, assuming 2's complement works. */
vbase = td.table - read_uoffset(buf, td.table);
verify((soffset_t)vbase >= 0 && !(vbase & (voffset_size - 1)), flatcc_verify_error_vtable_offset_out_of_range_or_unaligned);
verify(vbase + voffset_size <= end, flatcc_verify_error_vtable_header_out_of_range);
/* Read vtable size. */
td.vsize = read_voffset(buf, vbase);
vend = vbase + td.vsize;
verify(vend <= end && !(td.vsize & (voffset_size - 1)), flatcc_verify_error_vtable_size_out_of_range_or_unaligned);
/* Optimizes away overflow check if uoffset_t is large enough. */
verify(uoffset_size > voffset_size || vend >= vbase, flatcc_verify_error_vtable_size_overflow);
verify(td.vsize >= 2 * voffset_size, flatcc_verify_error_vtable_header_too_small);
/* Read table size. */
td.tsize = read_voffset(buf, vbase + voffset_size);
verify(end - td.table >= td.tsize, flatcc_verify_error_table_size_out_of_range);
td.vtable = (uint8_t *)buf + vbase;
td.buf = buf;
td.end = end;
return tvf(&td);
}
/*
* Loads and sets up a wave struct.
*
* Returns pointer to a new wave file on success,
* NULL on non-aborting error.
*/
struct wave* ini_wave(char* filename)
{
struct wave* w;
w = malloc(sizeof(wave));
assert(open_and_read_file(filename, w) == RETURN_OKAY);
assert(check_header(w) == RETURN_OKAY);
assert(check_fmt_chunk(w) == RETURN_OKAY);
assert(check_data_chunk_start(w) == RETURN_OKAY);
w->numChannels = int_from_bytes_little_endian(w->waveFile->fmtChunk.NumChannels, 2);
w->sampleRate = w->waveFile->fmtChunk.SampleRate;
w->blockAlign = int_from_bytes_little_endian(w->waveFile->fmtChunk.BlockAlign, 2);
w->bytesPerSample = int_from_bytes_little_endian(w->waveFile->fmtChunk.BitsPerSample, 2)/BITS_PER_BYTE;
w->numSamples = (w->waveFile->dataChunkStart.Subchunk2Size)/(w->numChannels)/(w->bytesPerSample);
w->data = (void*)(&((w->waveFile)->data));
DPRINTF(PRINT_DIVISION);
DPRINTF("Sanity Check\n");
DPRINTF("w->numChannels: %d\n", w->numChannels);
DPRINTF("w->sampleRate: %d\n", w->sampleRate);
DPRINTF("w->blockAlign: %d\n", w->blockAlign);
DPRINTF("w->bytesPerSample: %d\n", w->bytesPerSample);
assert(w->bytesPerSample < sizeof(SAMPLE)); /* Otherwise, can't do computation safely. */
DPRINTF("w->numSamples: %d\n", w->numSamples);
DPRINTF("w->data: %p\n", w->data);
return w;
}
/**
* Try to load a savefile
*/
static bool try_load(ang_file *f, const struct blockinfo *loaders)
{
struct blockheader b;
errr err;
if (!check_header(f)) {
note("Savefile is corrupted -- incorrect file header.");
return FALSE;
}
/* Get the next block header */
while ((err = next_blockheader(f, &b)) == 0) {
loader_t loader = find_loader(&b, loaders);
if (!loader) {
note("Savefile block can't be read.");
note("Maybe try and load the savefile in an earlier version of Angband.");
return FALSE;
}
if (!load_block(f, &b, loader)) {
note(format("Savefile corrupted - Couldn't load block %s", b.name));
return FALSE;
}
}
if (err == -1) {
note("Savefile is corrupted -- block header mangled.");
return FALSE;
}
return TRUE;
}
void fname_size_test_aux(std::size_t size)
{
ar::lha::header head;
head.level = 1;
head.update_time = std::time(0);
head.attributes = ar::msdos::attributes::read_only;
head.path = std::string(size, 'A');
head.os = 'M';
io_ex::tmp_file archive;
ar::basic_lzh_file_sink<
io_ex::dont_close_device<io_ex::tmp_file>
> sink(io_ex::dont_close(archive));
sink.create_entry(head);
sink.close();
sink.close_archive();
io::seek(archive, 0, BOOST_IOS::beg);
ar::basic_lzh_file_source<io_ex::tmp_file> src(archive);
BOOST_CHECK(src.next_entry());
check_header(head, src.header());
typedef std::char_traits<char> traits_type;
BOOST_CHECK(traits_type::eq_int_type(io::get(src), traits_type::eof()));
BOOST_CHECK(!src.next_entry());
}
void test_lib__handler__redirect_c()
{
h2o_globalconf_t globalconf;
h2o_hostconf_t *hostconf;
h2o_pathconf_t *pathconf;
h2o_config_init(&globalconf);
hostconf = h2o_config_register_host(&globalconf, h2o_iovec_init(H2O_STRLIT("default")), 65535);
pathconf = h2o_config_register_path(hostconf, "/", 0);
h2o_redirect_register(pathconf, 0, 301, "https://example.com/bar/");
h2o_context_init(&ctx, test_loop, &globalconf);
{
h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx, ctx.globalconf->hosts);
conn->req.input.method = h2o_iovec_init(H2O_STRLIT("GET"));
conn->req.input.path = h2o_iovec_init(H2O_STRLIT("/"));
h2o_loopback_run_loop(conn);
ok(conn->req.res.status == 301);
ok(check_header(&conn->req.res, H2O_TOKEN_LOCATION, "https://example.com/bar/"));
ok(conn->body->size != 0);
h2o_loopback_destroy(conn);
}
{
h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx, ctx.globalconf->hosts);
conn->req.input.method = h2o_iovec_init(H2O_STRLIT("GET"));
conn->req.input.path = h2o_iovec_init(H2O_STRLIT("/abc"));
h2o_loopback_run_loop(conn);
ok(conn->req.res.status == 301);
ok(check_header(&conn->req.res, H2O_TOKEN_LOCATION, "https://example.com/bar/abc"));
ok(conn->body->size != 0);
h2o_loopback_destroy(conn);
}
{
h2o_loopback_conn_t *conn = h2o_loopback_create(&ctx, ctx.globalconf->hosts);
conn->req.input.method = h2o_iovec_init(H2O_STRLIT("HEAD"));
conn->req.input.path = h2o_iovec_init(H2O_STRLIT("/"));
h2o_loopback_run_loop(conn);
ok(conn->req.res.status == 301);
ok(check_header(&conn->req.res, H2O_TOKEN_LOCATION, "https://example.com/bar/"));
ok(conn->body->size == 0);
h2o_loopback_destroy(conn);
}
h2o_context_dispose(&ctx);
h2o_config_dispose(&globalconf);
}
