/*
* ======== prepare_file ========
*/
static int prepare_file(char * file_name, file_type type, elf_file_info *f_info)
{
struct stat st;
int status = 0;
char *access = ((type == INPUT_FILE) ? "r+b" : "w+b");
if ((f_info->fp = fopen(file_name, access)) == NULL) {
printf("could not open: %s\n", file_name);
status = 2;
goto exit;
}
if (type == INPUT_FILE) {
fstat(fileno(f_info->fp), &st);
f_info->size = st.st_size;
if (!f_info->size) {
printf("size is invalid: %s\n", file_name);
status = 3;
goto exit;
}
printf("\nPreparing Input ELF file: %s of size: %d\n", file_name,
f_info->size);
f_info->data = malloc(f_info->size);
if (!f_info->data) {
printf("allocation failed for reading %s\n", file_name);
status = 4;
goto exit;
}
fread(f_info->data, 1, f_info->size, f_info->fp);
status = check_image(f_info->data, f_info->size);
if (status) {
printf("Image check failed for %s\n", file_name);
status = 5;
goto exit;
}
status = read_headers(f_info);
if (status) {
printf("read_headers failed for %s\n", file_name);
status = 6;
goto exit;
}
printf("Preparation complete for %s\n", file_name);
}
else if (type == OUTPUT_FILE) {
printf("\nPreparing Output ELF file: %s\n", file_name);
status = allocate_headers(f_info);
if (status) {
printf("allocate_headers failed for %s\n", file_name);
status = 7;
goto exit;
}
printf("Preparation complete for %s\n", file_name);
}
exit:
return status;
}
int main (int argc, char *argv[])
{
if(/*argc != 2 &&*/ argc != 5) {
fprintf(stderr, "Wrong argument count!\n");
return 1;
}
long tmp = strtol(argv[1], (char **)NULL, 10);
if(tmp < 0 || tmp > 255) {
fprintf(stderr, "Incorrect red mask value!\n");
exit(1);
}
char redmask = (char) tmp;
tmp = strtol(argv[2], (char **)NULL, 10);
if(tmp < 0 || tmp > 255) {
fprintf(stderr, "Incorrect green mask value!\n");
exit(1);
}
char greenmask = (char) tmp;
tmp = strtol(argv[3], (char **)NULL, 10);
if(tmp < 0 || tmp > 255) {
fprintf(stderr, "Incorrect blue mask value!\n");
exit(1);
}
char bluemask = (char) tmp;
FILE *fp = fopen(argv[4], "r");
if(!fp) {
perror(argv[4]);
exit(1);
}
read_headers(fp);
struct pixel *original = read_pixels(fp);
fclose(fp);
char buff[256];
snprintf(buff, 256, "%s%s", argv[2], ".game");
fp = fopen(buff, "w");
if(!fp) {
perror(buff);
exit(1);
}
struct pixel *modified = game(original, redmask, greenmask, bluemask);
/*write_file(fp, modified);*/
return 0;
}
int http_request(int fd)
{
int file;
struct stat file_stat;
char buffer[DEFAULT_BUFFER_SIZE] ={0};
char method[32] ={0};
char version[32] ={0}; // ignore
char uri[DEFAULT_BUFFER_SIZE] = {0};
char path[DEFAULT_BUFFER_SIZE] = {0};
//char cgiargs[DEFAULT_BUFFER_SIZE];
if (read_method(fd, buffer, sizeof buffer) < 0) {
http_error(fd, hst_bad_request);
return -1;
}
//printf("first line : %s\n", buffer);
sscanf(buffer, "%s %s %s", method, uri, version);
if (strcasecmp(method, method_GET) != 0) {
http_error(fd, hst_no_implemented);
return -1;
}
printf("mathod is GET, uri is %s\n", uri);
read_headers(fd, buffer, sizeof buffer); // ignore all hreaders
//printf("DEBUG\n");
if (parse_uri(uri, path) < 0) {
http_error(fd, hst_not_found);
return -1;
}
printf("file path is %s\n", path);
if (stat(path, &file_stat) < 0) {
http_error(fd, hst_not_found);
return -1;
}
if((file = open(path, O_RDONLY)) < 0) {
http_error(fd, hst_uknown);
return -1;
}
if(send_file(fd, file) < 0){
return -1;
}
return 0;
}
/**
* take the test file and use it to set up the request headers.
*/
void setup_request_headers(test_request &req, std::istream &in) {
typedef std::map<std::string, std::string> dict;
dict headers = read_headers(in, "---");
BOOST_FOREACH(const dict::value_type &val, headers) {
std::string key(val.first);
al::to_upper(key);
al::replace_all(key, "-", "_");
if (key == "DATE") {
req.set_current_time(parse_time(val.second));
} else {
req.set_header(key, val.second);
}
}
static void
reload (an_object_file_ptr pobj, string path)
{
string old_name = pobj->name;
unsigned old_name_index = pobj->name_ndx;
int fd;
unread_sections (pobj);
unread_obj (pobj, FALSE);
BZERO (pobj, sizeof(an_object_file));
pobj->other_name = old_name;
pobj->other_name_ndx = old_name_index;
pobj->name = path;
pobj->name_ndx = string_find_offset(path);
/* copied from pass1 */
fd = open_file (path, TRUE, FALSE, 0);
if (!use_mmap)
pobj->access_method = AM_READ;
pobj->ftype = read_headers (pobj, fd, FALSE);
LD_ASSERT (pobj->ftype == FT_OBJ, thisfile,
"incorrect file type from back end");
add_object (pobj);
msg(ER_DEFAULT /* ER_VERBOSE */ , ERN_LOAD_OBJ, num_objects_linked, pobj->name);
if (bsdmap)
printf("%s\n", pobj->other_name);
process_object (pobj);
if (optsym[OPTSYM_MDEPEND].num)
update_make_depend (pobj->other_name);
unread_sections (pobj);
close (fd);
delay_load = DL_DEFAULT;
if (hides != HS_IGNORE) {
hides = HS_DEFAULT;
}
} /* reload */
gboolean
ews_oab_decompress_full (const gchar *filename, const gchar *output_filename,
GError **error)
{
LzxHeader *lzx_h = NULL;
guint total_decomp_size = 0;
FILE *input, *output = NULL;
gboolean ret = TRUE;
GError *err = NULL;
input = fopen (filename, "rb");
if (!input) {
g_set_error_literal (&err, g_quark_from_string ("lzx"), 1, "unable to open the input file");
ret = FALSE;
goto exit;
}
output = fopen (output_filename, "wb");
if (!output) {
g_set_error_literal (&err, g_quark_from_string ("lzx"), 1, "unable to open the output file");
ret = FALSE;
goto exit;
}
lzx_h = read_headers (input, &err);
if (!lzx_h) {
ret = FALSE;
goto exit;
}
/* TODO decompressing multiple lzx_blocks has not been tested yet. Will need to get a setup and test it. */
do {
LzxBlockHeader *lzx_b;
struct lzxd_stream *lzs;
goffset offset;
lzx_b = read_block_header (input, &err);
if (err) {
ret = FALSE;
goto exit;
}
/* note the file offset */
offset = ftell (input);
/* lzx_b points to 1, write it directly to file */
if (lzx_b->flags == 0) {
gchar *buffer = g_malloc0 (lzx_b->ucomp_size);
if (!(fread (buffer, 1, lzx_b->ucomp_size, input) == lzx_b->ucomp_size &&
fwrite (buffer, 1, lzx_b->ucomp_size, output) == lzx_b->ucomp_size)) {
g_set_error_literal (&err, g_quark_from_string ("lzx"), 1, "failed to write data in output file");
g_free (buffer);
ret = FALSE;
goto exit;
}
g_free (buffer);
} else {
/* The window size should be the smallest power of two between 2^17 and 2^25 that is
greater than or equal to the sum of the size of the reference data rounded up to
a multiple of 32768 and the size of the subject data. Since we have no reference
data, forget that and the rounding. Just the smallest power of two which is large
enough to cover the subject data (lzx_b->ucomp_size). */
guint window_bits = g_bit_nth_msf(lzx_b->ucomp_size - 1, -1) + 1;
if (window_bits < 17)
window_bits = 17;
else if (window_bits > 25)
window_bits = 25;
lzs = ews_lzxd_init (input, output, window_bits,
0, 4096, lzx_b->ucomp_size, 1);
if (!lzs) {
g_set_error_literal (&err, g_quark_from_string ("lzx"), 1, "decompression failed (lzxd_init)");
ret = FALSE;
goto exit;
}
if (ews_lzxd_decompress (lzs, lzx_b->ucomp_size) != LZX_ERR_OK) {
g_set_error_literal (&err, g_quark_from_string ("lzx"), 1, "decompression failed (lzxd_decompress)");
ret = FALSE;
goto exit;
}
}
/* Set the fp to beggining of next block. This is a HACK, looks like decompress reads beyond the block.
* Since we can identify the next block start from block header, we just reset the offset */
offset += lzx_b->comp_size;
fseek (input, offset, SEEK_SET);
total_decomp_size += lzx_b->ucomp_size;
g_free (lzx_b);
} while (total_decomp_size < lzx_h->target_size);
exit:
if (input)
fclose (input);
if (output)
fclose (output);
if (err) {
ret = FALSE;
g_propagate_error (error, err);
g_unlink (output_filename);
}
g_free (lzx_h);
return ret;
}
bool http_connection::loop(unsigned fd)
{
socket_wrapper::io_vector io_vector[2];
size_t total = 0;
size_t count;
bool ret;
do {
logger::instance().log(logger::LOG_DEBUG, "[http_connection::loop] (fd %d) State = %s.", fd, state_to_string(_M_state));
switch (_M_state) {
case BEGIN_REQUEST_STATE:
if ((!_M_readable) && (_M_inp == (off_t) _M_in.count())) {
return true;
}
if (!read_request_line(fd, total)) {
return false;
}
break;
case READING_HEADERS_STATE:
if (!_M_readable) {
return true;
}
if (!read_headers(fd, total)) {
return false;
}
break;
case PROCESSING_REQUEST_STATE:
if (!process_request(fd)) {
return false;
}
if (_M_error != http_error::OK) {
total = 0;
_M_state = PREPARING_ERROR_PAGE_STATE;
} else {
if ((_M_state != PREPARING_HTTP_REQUEST_STATE) && (_M_state != READING_BODY_STATE) && (_M_state != READING_CHUNKED_BODY_STATE)) {
if (!modify(fd, tcp_server::WRITE)) {
return false;
}
total = 0;
}
}
break;
case READING_BODY_STATE:
if (!_M_readable) {
return true;
}
if (!read_body(fd, total)) {
return false;
}
break;
case READING_CHUNKED_BODY_STATE:
if (!_M_readable) {
return true;
}
if (!read_chunked_body(fd, total)) {
return false;
}
break;
case PREPARING_HTTP_REQUEST_STATE:
if (!prepare_http_request(fd)) {
_M_state = PREPARING_ERROR_PAGE_STATE;
} else {
_M_state = WAITING_FOR_BACKEND_STATE;
}
break;
case WAITING_FOR_BACKEND_STATE:
return true;
case PREPARING_ERROR_PAGE_STATE:
if ((!prepare_error_page()) || (!modify(fd, tcp_server::WRITE))) {
return false;
}
break;
case SENDING_TWO_BUFFERS_STATE:
if (!_M_writable) {
return true;
}
io_vector[0].iov_base = _M_out.data();
io_vector[0].iov_len = _M_out.count();
io_vector[1].iov_base = _M_bodyp->data();
io_vector[1].iov_len = _M_bodyp->count();
if (!writev(fd, io_vector, 2, total)) {
return false;
} else if (_M_outp == (off_t) (_M_out.count() + _M_bodyp->count())) {
_M_state = REQUEST_COMPLETED_STATE;
}
break;
case SENDING_HEADERS_STATE:
if (!_M_writable) {
return true;
}
if (!write(fd, total)) {
return false;
} else if (_M_outp == (off_t) _M_out.count()) {
if (_M_method == http_method::HEAD) {
_M_state = REQUEST_COMPLETED_STATE;
} else if (_M_error != http_error::OK) {
_M_state = REQUEST_COMPLETED_STATE;
} else if (_M_filesize == 0) {
_M_state = REQUEST_COMPLETED_STATE;
} else {
if (_M_ranges.count() == 0) {
_M_outp = 0;
} else {
const range_list::range* range = _M_ranges.get(0);
_M_outp = range->from;
}
_M_state = SENDING_BODY_STATE;
}
}
break;
case SENDING_BODY_STATE:
if (!_M_writable) {
return true;
}
if (!sendfile(fd, _M_fd, _M_filesize, &_M_ranges, _M_nrange, total)) {
return false;
} else {
size_t nranges = _M_ranges.count();
if (nranges == 0) {
if (_M_outp == _M_filesize) {
socket_wrapper::uncork(fd);
_M_state = REQUEST_COMPLETED_STATE;
}
} else {
const range_list::range* range = _M_ranges.get(_M_nrange);
if (_M_outp == range->to + 1) {
if (nranges == 1) {
socket_wrapper::uncork(fd);
_M_state = REQUEST_COMPLETED_STATE;
} else {
_M_out.reset();
// Last part?
if (++_M_nrange == nranges) {
if (!_M_out.format("\r\n--%0*u--\r\n", http_headers::BOUNDARY_WIDTH, _M_boundary)) {
return false;
}
_M_state = SENDING_MULTIPART_FOOTER_STATE;
} else {
if (!build_part_header()) {
return false;
}
_M_state = SENDING_PART_HEADER_STATE;
}
_M_outp = 0;
}
}
}
}
break;
case SENDING_PART_HEADER_STATE:
if (!_M_writable) {
return true;
}
if (!write(fd, total)) {
return false;
} else if (_M_outp == (off_t) _M_out.count()) {
const range_list::range* range = _M_ranges.get(_M_nrange);
_M_outp = range->from;
_M_state = SENDING_BODY_STATE;
}
break;
case SENDING_MULTIPART_FOOTER_STATE:
if (!_M_writable) {
return true;
}
if (!write(fd, total)) {
return false;
} else if (_M_outp == (off_t) _M_out.count()) {
socket_wrapper::uncork(fd);
_M_state = REQUEST_COMPLETED_STATE;
}
break;
case SENDING_BACKEND_HEADERS_STATE:
if (!_M_writable) {
return true;
}
if ((!_M_payload_in_memory) || (_M_filesize == 0) || (_M_method == http_method::HEAD)) {
count = _M_out.count();
ret = write(fd, total);
} else {
io_vector[0].iov_base = _M_out.data();
io_vector[0].iov_len = _M_out.count();
if (_M_error == http_error::OK) {
io_vector[1].iov_base = _M_body.data() + _M_backend_response_header_size;
} else {
io_vector[1].iov_base = _M_bodyp->data();
}
io_vector[1].iov_len = _M_filesize;
count = io_vector[0].iov_len + io_vector[1].iov_len;
ret = writev(fd, io_vector, 2, total);
}
if (!ret) {
return false;
} else if (_M_outp == (off_t) count) {
if (_M_payload_in_memory) {
_M_state = REQUEST_COMPLETED_STATE;
} else {
_M_outp = 0;
_M_state = SENDING_BACKEND_BODY_STATE;
}
}
break;
case SENDING_BACKEND_BODY_STATE:
if (!_M_writable) {
return true;
}
if (!sendfile(fd, _M_tmpfile, _M_filesize, total)) {
return false;
} else if (_M_outp == _M_filesize) {
socket_wrapper::uncork(fd);
_M_state = REQUEST_COMPLETED_STATE;
}
break;
case REQUEST_COMPLETED_STATE:
if ((_M_vhost) && (_M_vhost->log_requests)) {
_M_vhost->log->log(*this, fd);
}
// Close connection?
if (!_M_keep_alive) {
return false;
} else {
if (!modify(fd, tcp_server::READ)) {
return false;
}
reset();
// If there is more data in the input buffer...
size_t left = _M_in.count() - _M_inp;
if (left > 0) {
// Move data at the beginning of the buffer.
char* data = _M_in.data();
memmove(data, data + _M_inp, left);
_M_in.set_count(left);
} else {
_M_in.reset();
}
_M_inp = 0;
}
break;
}
} while (!_M_in_ready_list);
return true;
}
int main(int argc, char **argv)
{
int argn;
FILE *tmpfp;
struct rfc2045 *rfcp;
struct mimeautoreply_s replyinfo;
const char *subj=0;
const char *txtfile=0, *mimefile=0;
const char *mimedsn=0;
int nosend=0;
const char *replymode="reply";
int replytoenvelope=0;
int donotquote=0;
const char *forwardsep="--- Forwarded message ---";
const char *replysalut="%F writes:";
struct rfc2045src *src;
setlocale(LC_ALL, "");
charset=unicode_default_chset();
sender=NULL;
for (argn=1; argn < argc; argn++)
{
char optc;
char *optarg;
if (argv[argn][0] != '-')
break;
if (strcmp(argv[argn], "--") == 0)
{
++argn;
break;
}
optc=argv[argn][1];
optarg=argv[argn]+2;
if (!*optarg)
optarg=NULL;
switch (optc) {
case 'c':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
if (optarg && *optarg)
{
char *p=libmail_u_convert_tobuf("",
optarg,
libmail_u_ucs4_native,
NULL);
if (!p)
{
fprintf(stderr, "Unknown charset: %s\n",
charset);
exit(1);
}
free(p);
charset=optarg;
}
continue;
case 't':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
txtfile=optarg;
continue;
case 'm':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
mimefile=optarg;
continue;
case 'r':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
recips=optarg;
continue;
case 'M':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
mimedsn=optarg;
continue;
case 'd':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
dbfile=optarg;
continue;
case 'e':
replytoenvelope=1;
continue;
case 'T':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
if (optarg && *optarg)
replymode=optarg;
continue;
case 'N':
donotquote=1;
continue;
case 'F':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
if (optarg && *optarg)
forwardsep=optarg;
continue;
case 'S':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
if (optarg && *optarg)
replysalut=optarg;
continue;
case 'D':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
interval=optarg ? atoi(optarg):1;
continue;
case 'A':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
if (optarg)
{
struct header **h;
for (h= &extra_headers; *h;
h= &(*h)->next)
;
if ((*h=malloc(sizeof(struct header))) == 0 ||
((*h)->buf=strdup(optarg)) == 0)
{
perror("malloc");
exit(EX_TEMPFAIL);
}
(*h)->next=0;
}
continue;
case 's':
if (!optarg && argn+1 < argc)
optarg=argv[++argn];
subj=optarg;
continue;
case 'f':
if (optarg && *optarg)
{
sender=strdup(optarg);
}
else
{
sender=getenv("SENDER");
if (!sender)
continue;
sender=strdup(sender);
}
if (sender == NULL)
{
perror("malloc");
exit(1);
}
continue;
case 'n':
nosend=1;
continue;
default:
usage();
}
}
if (!txtfile && !mimefile)
usage();
if (txtfile && mimefile)
usage();
tmpfp=tmpfile();
if (!tmpfp)
{
perror("tmpfile");
exit(1);
}
rfcp=savemessage(tmpfp);
if (fseek(tmpfp, 0L, SEEK_SET) < 0)
{
perror("fseek(tempfile)");
exit(1);
}
read_headers(tmpfp);
if (sender == NULL || *sender == 0)
check_sender();
check_dsn();
check_recips();
#ifdef DbObj
check_db();
#endif
src=rfc2045src_init_fd(fileno(tmpfp));
memset(&replyinfo, 0, sizeof(replyinfo));
replyinfo.info.src=src;
replyinfo.info.rfc2045partp=rfcp;
replyinfo.info.voidarg=&replyinfo;
replyinfo.info.write_func=mimeautoreply_write_func;
replyinfo.info.writesig_func=mimeautoreply_writesig_func;
replyinfo.info.myaddr_func=mimeautoreply_myaddr_func;
replyinfo.info.replymode=replymode;
replyinfo.info.replytoenvelope=replytoenvelope;
replyinfo.info.donotquote=donotquote;
replyinfo.info.replysalut=replysalut;
replyinfo.info.forwarddescr="Forwarded message";
replyinfo.info.mailinglists="";
replyinfo.info.charset=charset;
replyinfo.info.subject=subj;
replyinfo.info.forwardsep=forwardsep;
if (mimedsn && *mimedsn)
{
replyinfo.info.dsnfrom=mimedsn;
replyinfo.info.replymode="replydsn";
}
if (mimefile)
{
if ((replyinfo.contentf=fopen(mimefile, "r")) == NULL)
{
perror(mimefile);
exit(1);
}
{
struct rfc2045 *rfcp=rfc2045_alloc();
static const char mv[]="Mime-Version: 1.0\n";
char buf[BUFSIZ];
int l;
const char *content_type;
const char *content_transfer_encoding;
const char *charset;
rfc2045_parse(rfcp, mv, sizeof(mv)-1);
while ((l=fread(buf, 1, sizeof(buf), replyinfo.contentf)
) > 0)
{
rfc2045_parse(rfcp, buf, l);
}
if (l < 0 ||
fseek(replyinfo.contentf, 0L, SEEK_SET) < 0)
{
perror(mimefile);
exit(1);
}
rfc2045_mimeinfo(rfcp, &content_type,
&content_transfer_encoding,
&charset);
if (strcasecmp(content_type, "text/plain"))
{
fprintf(stderr,
"%s must specify text/plain MIME type\n",
mimefile);
exit(1);
}
{
char *p=NULL;
if (charset)
p=libmail_u_convert_tobuf("",
charset,
libmail_u_ucs4_native,
NULL);
if (!p)
{
fprintf(stderr, "Unknown charset in %s\n",
mimefile);
exit(1);
}
free(p);
replyinfo.info.charset=strdup(charset);
}
rfc2045_free(rfcp);
}
replyinfo.info.content_set_charset=copy_headers;
replyinfo.info.content_specify=copy_body;
}
else if (txtfile)
{
if ((replyinfo.contentf=fopen(txtfile, "r")) == NULL)
{
perror(mimefile);
exit(1);
}
replyinfo.info.content_specify=copy_body;
}
if (replyinfo.contentf)
fcntl(fileno(replyinfo.contentf), F_SETFD, FD_CLOEXEC);
if (nosend)
replyinfo.outf=stdout;
else
{
replyinfo.outf=tmpfile();
if (replyinfo.outf == NULL)
{
perror("tmpfile");
exit(1);
}
}
{
struct header *h;
for (h=extra_headers; h; h=h->next)
fprintf(replyinfo.outf, "%s\n", h->buf);
}
fprintf(replyinfo.outf,
"Precedence: junk\n"
"Auto-Submitted: auto-replied\n");
if (rfc2045_makereply(&replyinfo.info) < 0 ||
fflush(replyinfo.outf) < 0 || ferror(replyinfo.outf) ||
(!nosend &&
(
fseek(replyinfo.outf, 0L, SEEK_SET) < 0 ||
(close(0), dup(fileno(replyinfo.outf))) < 0)
))
{
perror("tempfile");
exit(1);
}
fclose(replyinfo.outf);
fcntl(0, F_SETFD, 0);
rfc2045_free(rfcp);
rfc2045src_deinit(src);
if (!nosend)
opensendmail(argn, argc, argv);
return (0);
}
grub_err_t
SUFFIX (grub_freebsd_load_elfmodule_obj) (grub_file_t file, int argc,
char *argv[], grub_addr_t *kern_end)
{
Elf_Ehdr e;
Elf_Shdr *s;
char *shdr;
grub_addr_t curload, module;
grub_err_t err;
err = read_headers (file, &e, &shdr);
if (err)
return err;
curload = module = ALIGN_PAGE (*kern_end);
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) ((char *) shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
{
if (s->sh_size == 0)
continue;
if (s->sh_addralign)
curload = ALIGN_UP (curload, s->sh_addralign);
s->sh_addr = curload;
grub_dprintf ("bsd", "loading section to %x, size %d, align %d\n",
(unsigned) curload, (int) s->sh_size,
(int) s->sh_addralign);
switch (s->sh_type)
{
default:
case SHT_PROGBITS:
err = load (file, UINT_TO_PTR (curload), s->sh_offset, s->sh_size);
if (err)
return err;
break;
case SHT_NOBITS:
if (curload + s->sh_size > grub_os_area_addr + grub_os_area_size)
return grub_error (GRUB_ERR_OUT_OF_RANGE,
"not enough memory for the module");
grub_memset (UINT_TO_PTR (curload), 0, s->sh_size);
break;
}
curload += s->sh_size;
}
*kern_end = ALIGN_PAGE (curload);
err = grub_freebsd_add_meta_module (argv[0], FREEBSD_MODTYPE_ELF_MODULE_OBJ,
argc - 1, argv + 1, module,
curload - module);
if (! err)
err = grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA
| FREEBSD_MODINFOMD_ELFHDR,
&e, sizeof (e));
if (! err)
err = grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA
| FREEBSD_MODINFOMD_SHDR,
shdr, e.e_shnum * e.e_shentsize);
return err;
}
/* Attempts to push forward the reading side of @msg's I/O. Returns
* %TRUE if it manages to make some progress, and it is likely that
* further progress can be made. Returns %FALSE if it has reached a
* stopping point of some sort (need input from the application,
* socket not readable, read is complete, etc).
*/
static gboolean
io_read (SoupMessage *msg, gboolean blocking,
GCancellable *cancellable, GError **error)
{
SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
SoupMessageIOData *io = priv->io_data;
guchar *stack_buf = NULL;
gssize nread;
SoupBuffer *buffer;
guint status;
switch (io->read_state) {
case SOUP_MESSAGE_IO_STATE_HEADERS:
if (!read_headers (msg, blocking, cancellable, error))
return FALSE;
status = io->parse_headers_cb (msg, (char *)io->read_header_buf->data,
io->read_header_buf->len,
&io->read_encoding,
io->header_data, error);
g_byte_array_set_size (io->read_header_buf, 0);
if (status != SOUP_STATUS_OK) {
/* Either we couldn't parse the headers, or they
* indicated something that would mean we wouldn't
* be able to parse the body. (Eg, unknown
* Transfer-Encoding.). Skip the rest of the
* reading, and make sure the connection gets
* closed when we're done.
*/
soup_message_set_status (msg, status);
soup_message_headers_append (msg->request_headers,
"Connection", "close");
io->read_state = SOUP_MESSAGE_IO_STATE_FINISHING;
break;
}
if (io->mode == SOUP_MESSAGE_IO_CLIENT &&
SOUP_STATUS_IS_INFORMATIONAL (msg->status_code)) {
if (msg->status_code == SOUP_STATUS_CONTINUE &&
io->write_state == SOUP_MESSAGE_IO_STATE_BLOCKING) {
/* Pause the reader, unpause the writer */
io->read_state =
SOUP_MESSAGE_IO_STATE_BLOCKING;
io->write_state =
SOUP_MESSAGE_IO_STATE_BODY_START;
} else {
/* Just stay in HEADERS */
io->read_state = SOUP_MESSAGE_IO_STATE_HEADERS;
}
/* Informational responses have no bodies, so
* bail out here rather than parsing encoding, etc
*/
soup_message_got_informational (msg);
/* If this was "101 Switching Protocols", then
* the session may have stolen the connection...
*/
if (io != priv->io_data)
return FALSE;
soup_message_cleanup_response (msg);
break;
} else if (io->mode == SOUP_MESSAGE_IO_SERVER &&
soup_message_headers_get_expectations (msg->request_headers) & SOUP_EXPECTATION_CONTINUE) {
/* We must return a status code and response
* headers to the client; either an error to
* be set by a got-headers handler below, or
* else %SOUP_STATUS_CONTINUE otherwise.
*/
io->write_state = SOUP_MESSAGE_IO_STATE_HEADERS;
io->read_state = SOUP_MESSAGE_IO_STATE_BLOCKING;
} else {
io->read_state = SOUP_MESSAGE_IO_STATE_BODY_START;
/* If the client was waiting for a Continue
* but got something else, then it's done
* writing.
*/
if (io->mode == SOUP_MESSAGE_IO_CLIENT &&
io->write_state == SOUP_MESSAGE_IO_STATE_BLOCKING)
io->write_state = SOUP_MESSAGE_IO_STATE_FINISHING;
}
if (io->read_encoding == SOUP_ENCODING_CONTENT_LENGTH) {
SoupMessageHeaders *hdrs =
(io->mode == SOUP_MESSAGE_IO_CLIENT) ?
msg->response_headers : msg->request_headers;
io->read_length = soup_message_headers_get_content_length (hdrs);
if (io->mode == SOUP_MESSAGE_IO_CLIENT &&
!soup_message_is_keepalive (msg)) {
/* Some servers suck and send
* incorrect Content-Length values, so
* allow EOF termination in this case
* (iff the message is too short) too.
*/
io->read_encoding = SOUP_ENCODING_EOF;
}
} else
io->read_length = -1;
soup_message_got_headers (msg);
break;
case SOUP_MESSAGE_IO_STATE_BODY_START:
if (!io->body_istream) {
GInputStream *body_istream = soup_body_input_stream_new (G_INPUT_STREAM (io->istream),
io->read_encoding,
io->read_length);
/* TODO: server-side messages do not have a io->item. This means
* that we cannot use content processors for them right now.
*/
if (io->mode == SOUP_MESSAGE_IO_CLIENT) {
io->body_istream = soup_message_setup_body_istream (body_istream, msg,
io->item->session,
SOUP_STAGE_MESSAGE_BODY);
g_object_unref (body_istream);
} else {
io->body_istream = body_istream;
}
}
if (priv->sniffer) {
SoupContentSnifferStream *sniffer_stream = SOUP_CONTENT_SNIFFER_STREAM (io->body_istream);
const char *content_type;
GHashTable *params;
if (!soup_content_sniffer_stream_is_ready (sniffer_stream, blocking,
cancellable, error))
return FALSE;
content_type = soup_content_sniffer_stream_sniff (sniffer_stream, ¶ms);
soup_message_content_sniffed (msg, content_type, params);
}
io->read_state = SOUP_MESSAGE_IO_STATE_BODY;
break;
case SOUP_MESSAGE_IO_STATE_BODY:
if (priv->chunk_allocator) {
buffer = priv->chunk_allocator (msg, io->read_length, priv->chunk_allocator_data);
if (!buffer) {
g_return_val_if_fail (!io->item || !io->item->new_api, FALSE);
soup_message_io_pause (msg);
return FALSE;
}
} else {
if (!stack_buf)
stack_buf = alloca (RESPONSE_BLOCK_SIZE);
buffer = soup_buffer_new (SOUP_MEMORY_TEMPORARY,
stack_buf,
RESPONSE_BLOCK_SIZE);
}
nread = g_pollable_stream_read (io->body_istream,
(guchar *)buffer->data,
buffer->length,
blocking,
cancellable, error);
if (nread > 0) {
buffer->length = nread;
soup_message_body_got_chunk (io->read_body, buffer);
soup_message_got_chunk (msg, buffer);
soup_buffer_free (buffer);
break;
}
soup_buffer_free (buffer);
if (nread == -1)
return FALSE;
/* else nread == 0 */
io->read_state = SOUP_MESSAGE_IO_STATE_BODY_DONE;
break;
case SOUP_MESSAGE_IO_STATE_BODY_DONE:
io->read_state = SOUP_MESSAGE_IO_STATE_FINISHING;
soup_message_got_body (msg);
break;
case SOUP_MESSAGE_IO_STATE_FINISHING:
io->read_state = SOUP_MESSAGE_IO_STATE_DONE;
if (io->mode == SOUP_MESSAGE_IO_SERVER)
io->write_state = SOUP_MESSAGE_IO_STATE_HEADERS;
break;
default:
g_return_val_if_reached (FALSE);
}
return TRUE;
}
grub_err_t
SUFFIX(grub_openbsd_find_ramdisk) (grub_file_t file,
grub_addr_t kern_start,
void *kern_chunk_src,
struct grub_openbsd_ramdisk_descriptor *desc)
{
unsigned symoff, stroff, symsize, strsize, symentsize;
{
grub_err_t err;
Elf_Ehdr e;
Elf_Shdr *s;
char *shdr = NULL;
err = read_headers (file, &e, &shdr);
if (err)
return err;
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) (shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
if (s->sh_type == SHT_SYMTAB)
break;
if (s >= (Elf_Shdr *) ((char *) shdr + e.e_shnum * e.e_shentsize))
{
grub_free (shdr);
return GRUB_ERR_NONE;
}
symsize = s->sh_size;
symentsize = s->sh_entsize;
symoff = s->sh_offset;
s = (Elf_Shdr *) (shdr + e.e_shentsize * s->sh_link);
stroff = s->sh_offset;
strsize = s->sh_size;
grub_free (shdr);
}
{
Elf_Sym *syms, *sym, *imagesym = NULL, *sizesym = NULL;
unsigned i;
char *strs;
syms = grub_malloc (symsize);
if (!syms)
return grub_errno;
if (grub_file_seek (file, symoff) == (grub_off_t) -1)
{
grub_free (syms);
return grub_errno;
}
if (grub_file_read (file, syms, symsize) != (grub_ssize_t) symsize)
{
grub_free (syms);
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_errno;
}
strs = grub_malloc (strsize);
if (!strs)
{
grub_free (syms);
return grub_errno;
}
if (grub_file_seek (file, stroff) == (grub_off_t) -1)
return grub_errno;
if (grub_file_read (file, strs, strsize) != (grub_ssize_t) strsize)
{
grub_free (syms);
grub_free (strs);
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_errno;
}
for (i = 0, sym = syms; i < symsize / symentsize;
i++, sym = (Elf_Sym *) ((char *) sym + symentsize))
{
if (ELF_ST_TYPE (sym->st_info) != STT_OBJECT)
continue;
if (!sym->st_name)
continue;
if (grub_strcmp (strs + sym->st_name, "rd_root_image") == 0)
imagesym = sym;
if (grub_strcmp (strs + sym->st_name, "rd_root_size") == 0)
sizesym = sym;
if (imagesym && sizesym)
break;
}
if (!imagesym || !sizesym)
{
grub_free (syms);
grub_free (strs);
return GRUB_ERR_NONE;
}
if (sizeof (*desc->size) != sizesym->st_size)
{
grub_free (syms);
grub_free (strs);
return grub_error (GRUB_ERR_BAD_OS, "unexpected size of rd_root_size");
}
desc->max_size = imagesym->st_size;
desc->target = (imagesym->st_value & 0xFFFFFF) - kern_start
+ (grub_uint8_t *) kern_chunk_src;
desc->size = (grub_uint32_t *) ((sizesym->st_value & 0xFFFFFF) - kern_start
+ (grub_uint8_t *) kern_chunk_src);
grub_free (syms);
grub_free (strs);
return GRUB_ERR_NONE;
}
}
grub_err_t
SUFFIX (grub_freebsd_load_elf_meta) (struct grub_relocator *relocator,
grub_file_t file, grub_addr_t *kern_end)
{
grub_err_t err;
Elf_Ehdr e;
Elf_Shdr *s;
char *shdr = 0;
unsigned symoff, stroff, symsize, strsize;
grub_freebsd_addr_t symstart, symend, symentsize, dynamic;
Elf_Sym *sym;
void *sym_chunk;
grub_uint8_t *curload;
grub_freebsd_addr_t symtarget;
const char *str;
unsigned i;
grub_size_t chunk_size;
err = read_headers (file, &e, &shdr);
if (err)
return err;
err = grub_bsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_ELFHDR, &e,
sizeof (e));
if (err)
return err;
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) (shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
if (s->sh_type == SHT_SYMTAB)
break;
if (s >= (Elf_Shdr *) ((char *) shdr
+ e.e_shnum * e.e_shentsize))
return grub_error (GRUB_ERR_BAD_OS, "no symbol table");
symoff = s->sh_offset;
symsize = s->sh_size;
symentsize = s->sh_entsize;
s = (Elf_Shdr *) (shdr + e.e_shentsize * s->sh_link);
stroff = s->sh_offset;
strsize = s->sh_size;
chunk_size = ALIGN_UP (symsize + strsize, sizeof (grub_freebsd_addr_t))
+ 2 * sizeof (grub_freebsd_addr_t);
symtarget = ALIGN_UP (*kern_end, sizeof (grub_freebsd_addr_t));
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
symtarget, chunk_size);
if (err)
return err;
sym_chunk = get_virtual_current_address (ch);
}
symstart = symtarget;
symend = symstart + chunk_size;
curload = sym_chunk;
*((grub_freebsd_addr_t *) curload) = symsize;
curload += sizeof (grub_freebsd_addr_t);
if (grub_file_seek (file, symoff) == (grub_off_t) -1)
return grub_errno;
sym = (Elf_Sym *) curload;
if (grub_file_read (file, curload, symsize) != (grub_ssize_t) symsize)
{
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_errno;
}
curload += symsize;
*((grub_freebsd_addr_t *) curload) = strsize;
curload += sizeof (grub_freebsd_addr_t);
if (grub_file_seek (file, stroff) == (grub_off_t) -1)
return grub_errno;
str = (char *) curload;
if (grub_file_read (file, curload, strsize) != (grub_ssize_t) strsize)
{
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_errno;
}
for (i = 0;
i * symentsize < symsize;
i++, sym = (Elf_Sym *) ((char *) sym + symentsize))
{
const char *name = str + sym->st_name;
if (grub_strcmp (name, "_DYNAMIC") == 0)
break;
}
if (i * symentsize < symsize)
{
dynamic = sym->st_value;
grub_dprintf ("bsd", "dynamic = %llx\n", (unsigned long long) dynamic);
err = grub_bsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_DYNAMIC, &dynamic,
sizeof (dynamic));
if (err)
return err;
}
err = grub_bsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_SSYM, &symstart,
sizeof (symstart));
if (err)
return err;
err = grub_bsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_ESYM, &symend,
sizeof (symend));
if (err)
return err;
*kern_end = ALIGN_PAGE (symend);
return GRUB_ERR_NONE;
}
static void decrypt(struct mimestack **stack, int *iseof,
struct header *h,
FILE *fpin, FILE *fpout, int argc, char **argv)
{
struct header *p, *q;
char temp_file[TEMPNAMEBUFSIZE];
int temp_fd;
FILE *temp_fp;
struct mime_header *mh;
int flag;
temp_fd=mimegpg_tempfile(temp_file);
if (temp_fd < 0 || (temp_fp=fdopen(temp_fd, "w+")) == 0)
{
if (temp_fd >= 0)
close(temp_fd);
perror("open");
exit(1);
}
for (p=h; p; p=p->next)
{
fprintf(temp_fp, "%s", p->header);
}
putc('\n', temp_fp);
find_boundary(stack, iseof, fpin, temp_fp, 0);
if (*iseof)
{
fclose(temp_fp);
unlink(temp_file);
return;
}
p=read_headers(stack, iseof, fpin, temp_fp, 0);
if (*iseof)
{
free_header(p);
fclose(temp_fp);
unlink(temp_file);
return;
}
q=find_header(p, "content-type:");
flag=0;
if (q)
{
mh=parse_mime_header(q->header+13);
if (!mh)
{
perror("malloc");
free_header(p);
fclose(temp_fp);
unlink(temp_file);
exit(1);
}
if (strcasecmp(mh->header_name, "application/pgp-encrypted")
== 0)
flag=1;
free_mime_header(mh);
}
for (q=p; q; q=q->next)
{
fprintf(temp_fp, "%s", q->header);
}
free_header(p);
putc('\n', temp_fp);
p=read_headers(stack, iseof, fpin, temp_fp, 0);
if (*iseof)
{
free_header(p);
fclose(temp_fp);
unlink(temp_file);
return;
}
q=find_header(p, "version:");
if (flag)
{
if (!q || atoi(p->header + 8) != 1)
flag=0;
}
for (q=p; q; q=q->next)
{
fprintf(temp_fp, "%s", q->header);
}
free_header(p);
putc('\n', temp_fp);
find_boundary(stack, iseof, fpin, temp_fp, 0);
if (*iseof)
{
fclose(temp_fp);
unlink(temp_file);
return;
}
p=read_headers(stack, iseof, fpin, temp_fp, 0);
if (*iseof)
{
free_header(p);
fclose(temp_fp);
unlink(temp_file);
return;
}
q=find_header(p, "content-type:");
if (q && flag)
{
flag=0;
mh=parse_mime_header(q->header+13);
if (!mh)
{
perror("malloc");
free_header(p);
fclose(temp_fp);
unlink(temp_file);
exit(1);
}
if (strcasecmp(mh->header_name, "application/octet-stream")
== 0)
flag=1;
free_mime_header(mh);
q=find_header(p, "content-transfer-encoding:");
if (q && flag)
{
flag=0;
mh=parse_mime_header(strchr(q->header, ':')+1);
if (!mh)
{
perror("malloc");
free_header(p);
fclose(temp_fp);
unlink(temp_file);
exit(1);
}
if (strcasecmp(mh->header_name, "7bit") == 0 ||
strcasecmp(mh->header_name, "8bit") == 0)
flag=1;
free_mime_header(mh);
}
}
for (q=p; q; q=q->next)
{
fprintf(temp_fp, "%s", q->header);
}
free_header(p);
putc('\n', temp_fp);
if (fflush(temp_fp) || ferror(temp_fp) || my_rewind(temp_fp) < 0)
{
perror(temp_file);
fclose(temp_fp);
unlink(temp_file);
exit(1);
}
if (!flag)
{
int c;
while ((c=getc(temp_fp)) != EOF)
{
putc(c, fpout);
}
fclose(temp_fp);
unlink(temp_file);
close_mime(stack, iseof, fpin, fpout);
return;
}
fclose(temp_fp);
if ((temp_fp=fopen(temp_file, "w+")) == NULL)
{
perror(temp_file);
unlink(temp_file);
exit(1);
}
noexec(temp_fp);
dodecrypt(stack, iseof, fpin, temp_fp, argc, argv, temp_file,
fpout);
fclose(temp_fp);
unlink(temp_file);
}
int rx_packet_ready(void) {
read_headers();
rd_buf_addr = rd_packet_addr;
return packet_ready;
}
void client_thread(void *p) {
http_state_t * hs = (http_state_t *)p;
char * buf, * ext;
const char * ct;
file_t f = -1;
int r, o, cnt;
stat_t st;
printf("httpd: client thread started, sock %d\n", hs->socket);
buf = malloc(BUFSIZE);
if (read_headers(hs, buf, BUFSIZE) < 0) {
goto out;
}
printf("httpd: client requested '%s'\n", buf);
// Is it a directory or a file?
f = fs_open(buf, O_RDONLY | O_DIR);
if (f >= 0) {
do_dirlist(buf, hs, f);
} else {
f = fs_open(buf, O_RDONLY);
if (f < 0) {
send_error(hs, 404, "File not found or unreadable");
goto out;
}
ext = strrchr(buf, '.');
ct = "application/octet-stream";
if (ext) {
ext++;
if (!strcasecmp(ext, "jpg"))
ct = "image/jpeg";
else if (!strcasecmp(ext, "png"))
ct = "image/png";
else if (!strcasecmp(ext, "gif"))
ct = "image/gif";
else if (!strcasecmp(ext, "txt"))
ct = "text/plain";
else if (!strcasecmp(ext, "mp3"))
ct = "audio/mpeg";
else if (!strcasecmp(ext, "ogg"))
ct = "application/ogg";
else if (!strcasecmp(ext, "html"))
ct = "text/html";
}
send_ok(hs, ct);
while ((cnt = fs_read(f, buf, BUFSIZE)) != 0) {
o = 0;
while (cnt > 0) {
r = write(hs->socket, buf+o, cnt);
if (r <= 0)
goto out;
cnt -= r;
o += r;
}
}
}
fs_close(f);
out:
free(buf);
printf("httpd: closed client connection %d\n", hs->socket);
close(hs->socket);
st_destroy(hs);
if (f >= 0)
fs_close(f);
}
/*
* asynchronus input (select) with the stdin and the socket connection
* to the server. copy input data from stdin to server, and
* copy received data from the server to stdout/stderr.
* destination of output is stdout or stderr are distinguished by
* stream identifier(sid) header is 'out' or 'err'.
*/
int start_session(int fd)
{
struct header_t headers[MAX_HEADER];
#ifdef WINDOWS
invoke_thread(fd);
#else
fd_set read_set;
int ret;
int stdin_closed = 0;
#endif
while (1) {
#ifdef UNIX
// initialize the set of file descriptor
FD_ZERO(&read_set);
// watch stdin of client and socket.
FD_SET(STDIN_FILENO, &read_set);
FD_SET(fd, &read_set);
if ((ret = select(fd + 1, &read_set, (fd_set*)NULL, (fd_set*)NULL, NULL)) == -1) {
perror("ERROR: select failure");
exit(1);
}
if (ret == 0) {
fprintf(stderr, "ERROR: timeout?\n");
continue;
}
// detect changed descriptor
if (!stdin_closed && FD_ISSET(STDIN_FILENO, &read_set)) { // stdin
#ifdef DEBUG
fprintf(stderr, "DEBUG: detect stdin\n");
#endif
stdin_closed = send_to_server(fd);
continue;
}
if (FD_ISSET(fd, &read_set) == FALSE){ // socket
#ifdef DEBUG
fprintf(stderr, "DEBUG: detect nothing\n");
#endif
continue;
}
#ifdef DEBUG
fprintf(stderr, "DEBUG: detect socket\n");
#endif
#endif
int size = read_headers(fd, headers);
if (size == 0) {
return 0; // as normal exit if header size 0
}
// Process exit
char* status = find_header(headers, HEADER_KEY_STATUS, size);
if (status != NULL) {
int stat = atoi(status);
return stat;
}
// Dispatch data from server to stdout/err.
char* sid = find_header(headers, HEADER_KEY_CHANNEL, size);
if (sid == NULL) {
fprintf(stderr, "ERROR: required header %s not found\n", HEADER_KEY_CHANNEL);
return 1;
}
char* chunk_size = find_header(headers, HEADER_KEY_SIZE, size);
if (chunk_size == NULL) {
fprintf(stderr, "ERROR: required header %s not found\n", HEADER_KEY_SIZE);
return 1;
}
if (receive_from_server(fd, sid, atoi(chunk_size)) == EOF) {
return 0;
}
}
}
/* extraHeaders is either NULL or a string with extra headers separated
* by '\r\n', ending with '\r\n'.
*/
int httpGetFileDesc(char * hostname, int port, char * remotename,
char *extraHeaders) {
char * buf, *headers = NULL;
char *status;
char *hstr;
int family;
struct in_addr addr;
struct in6_addr addr6;
int sock;
int rc;
struct sockaddr_in destPort;
struct sockaddr_in6 destPort6;
fd_set readSet;
#ifdef ROCKS
int bufsize;
#endif /* ROCKS */
if (port < 0)
port = 80;
family = AF_INET;
rc = getHostAddress(hostname, &addr, family);
if (rc) {
family = AF_INET6;
rc = getHostAddress(hostname, &addr6, family);
if (rc)
return rc;
}
sock = socket(family, SOCK_STREAM, IPPROTO_IP);
if (sock < 0) {
return FTPERR_FAILED_CONNECT;
}
if (family == AF_INET) {
destPort.sin_family = family;
destPort.sin_port = htons(port);
destPort.sin_addr = addr;
if (connect(sock, (struct sockaddr *) &destPort, sizeof(destPort))) {
close(sock);
return FTPERR_FAILED_CONNECT;
}
} else if (family == AF_INET6) {
destPort6.sin6_family = family;
destPort6.sin6_port = htons(port);
destPort6.sin6_addr = addr6;
if (connect(sock, (struct sockaddr *) &destPort6, sizeof(destPort6))) {
close(sock);
return FTPERR_FAILED_CONNECT;
}
}
if (extraHeaders)
hstr = extraHeaders;
else
hstr = "";
#ifdef ROCKS
bufsize = strlen(remotename) + strlen(hostname) + strlen(hstr) + 30;
if ((buf = malloc(bufsize)) == NULL) {
logMessage(ERROR, "ROCKS:httpGetFileDesc:malloc failed");
return FTPERR_FAILED_CONNECT;
}
#else
buf = alloca(strlen(remotename) + strlen(hostname) + strlen(hstr) + 25);
#endif /* ROCKS */
sprintf(buf, "GET %s HTTP/1.0\r\nHost: %s\r\n%s\r\n", remotename, hostname, hstr);
rc = write(sock, buf, strlen(buf));
#ifdef ROCKS
free(buf);
#endif /* ROCKS */
rc = read_headers (&headers, &readSet, sock);
if (rc < 0)
return rc;
status = find_status_code (headers);
if (status == NULL) {
close(sock);
return FTPERR_SERVER_IO_ERROR;
} else if (!strncmp(status, "200", 3)) {
return sock;
} else if (!strncmp(status, "301", 3) || !strncmp(status, "302", 3) ||
!strncmp(status, "303", 3) || !strncmp(status, "307", 3)) {
struct iurlinfo ui;
char *redir_loc = find_header (headers, "Location");
int retval;
if (redir_loc == NULL) {
logMessage(WARNING, "got a redirect response, but Location header is NULL");
close(sock);
return FTPERR_FILE_NOT_FOUND;
}
logMessage(INFO, "redirecting to %s", redir_loc);
convertURLToUI(redir_loc, &ui);
retval = httpGetFileDesc (ui.address, -1, ui.prefix, extraHeaders);
free(redir_loc);
return retval;
} else if (!strncmp(status, "403", 3)) {
close(sock);
return FTPERR_PERMISSION_DENIED;
} else if (!strncmp(status, "404", 3)) {
close(sock);
return FTPERR_FILE_NOT_FOUND;
#ifdef ROCKS
} else if (!strncmp(status, "503", 3)) {
/* A server nack - busy */
close(sock);
logMessage(WARNING, "ROCKS:server busy");
watchdog_reset();
return FTPERR_FAILED_DATA_CONNECT;
#endif /* ROCKS */
} else {
close(sock);
logMessage(ERROR, "bad HTTP response code: %s", status);
return FTPERR_BAD_SERVER_RESPONSE;
}
}
grub_err_t
SUFFIX (grub_freebsd_load_elfmodule) (grub_file_t file, int argc, char *argv[],
grub_addr_t *kern_end)
{
Elf_Ehdr e;
Elf_Shdr *s;
char *shdr;
grub_addr_t curload, module;
grub_err_t err;
err = read_headers (file, &e, &shdr);
if (err)
return err;
curload = module = ALIGN_PAGE (*kern_end);
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) ((char *) shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
{
if (s->sh_size == 0)
continue;
if (! (s->sh_flags & SHF_ALLOC))
continue;
grub_dprintf ("bsd", "loading section to %x, size %d, align %d\n",
(unsigned) curload, (int) s->sh_size,
(int) s->sh_addralign);
switch (s->sh_type)
{
default:
case SHT_PROGBITS:
err = load (file, UINT_TO_PTR (module + s->sh_addr),
s->sh_offset, s->sh_size);
if (err)
return err;
break;
case SHT_NOBITS:
if (module + s->sh_addr + s->sh_size
> grub_os_area_addr + grub_os_area_size)
return grub_error (GRUB_ERR_OUT_OF_RANGE,
"not enough memory for the module");
grub_memset (UINT_TO_PTR (module + s->sh_addr), 0, s->sh_size);
break;
}
if (curload < module + s->sh_addr + s->sh_size)
curload = module + s->sh_addr + s->sh_size;
}
load (file, UINT_TO_PTR (module), 0, sizeof (e));
if (curload < module + sizeof (e))
curload = module + sizeof (e);
load (file, UINT_TO_PTR (curload), e.e_shoff,
e.e_shnum * e.e_shentsize);
e.e_shoff = curload - module;
curload += e.e_shnum * e.e_shentsize;
load (file, UINT_TO_PTR (curload), e.e_phoff,
e.e_phnum * e.e_phentsize);
e.e_phoff = curload - module;
curload += e.e_phnum * e.e_phentsize;
*kern_end = curload;
grub_freebsd_add_meta_module (argv[0], FREEBSD_MODTYPE_ELF_MODULE,
argc - 1, argv + 1, module,
curload - module);
return SUFFIX (grub_freebsd_load_elf_meta) (file, kern_end);
}
long get_http_speed(int test_respond_size, const char * server_address, int port, const char * file_name, struct sockaddr_in address) {
// 记录请求开始时间
int response_speed = -1;
struct timeval time_start;
gettimeofday(&time_start, NULL);
// Open up a socket
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
DLog("Unable to open socket\n");
return -1;
}
if (connect(sockfd, (struct sockaddr*) &address, sizeof(address)) < 0) {
DLog("Unable to connect to host\n");
return -1;
}
DLog("Connected with host: %s\n", inet_ntoa(address.sin_addr));
// Define buffer size
const int buffer_size = 8096;
/*******************************************************/
/* Begin sending GET request */
/*******************************************************/
char buffer[buffer_size];
sprintf(buffer, "GET %s HTTP/1.1\r\n", file_name);
write_socket(sockfd, buffer, strlen(buffer));
sprintf(buffer, "Host: %s:%d\r\n", server_address, port);
write_socket(sockfd, buffer, strlen(buffer));
sprintf(buffer, "User-Agent: Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.16 Safari/537.36\r\n");
write_socket(sockfd, buffer, strlen(buffer));
sprintf(buffer, "Connection: close\r\n");
write_socket(sockfd, buffer, strlen(buffer));
// Signal end of headers with empty line
sprintf(buffer, "\r\n");
write_socket(sockfd, buffer, strlen(buffer));
/*******************************************************/
/* Begin reading response */
/*******************************************************/
// Read first line and print to console
int len = read_line(sockfd, buffer, sizeof(buffer));
if (len <= 0) {
DLog("No response received from server\n");
goto out;
} else {
print_current_time();
}
char version[16];
char response_code[16];
char response_reason[256];
int i, j;
// Read version
for(i = 0; i < sizeof(version) - 1 && !isspace(buffer[i]); i++) {
version[i] = buffer[i];
}
version[i] = '\0';
// Skip over spaces
for (; isspace(buffer[i]) && i < sizeof(buffer); i++);
// Read response code
for (j = 0; i < sizeof(buffer) && j < sizeof(response_code) - 1 && !isspace(buffer[i]); i++, j++) {
response_code[j] = buffer[i];
}
response_code[j] = '\0';
// Skip over spaces
for (; isspace(buffer[i]) && i < sizeof(buffer); i++);
// Read response reason
for (j = 0; i < sizeof(buffer) && j < sizeof(response_reason) - 1 && buffer[i] != '\n'; i++, j++) {
response_reason[j] = buffer[i];
}
response_reason[j] = '\0';
// DLog("Version: %s\n", version);
// DLog("Response Code: %s\n", response_code);
// DLog("Response Reason: %s\n", response_reason);
struct HeaderReturnStuct header_return = read_headers(sockfd);
if (strcmp(response_code, "200") != 0) {
if (strcmp(response_code, "301") == 0) {
DLog("%s Error: %s \n", response_code, response_reason);
} else {
DLog("%s Error: %s\n", response_code, response_reason);
}
goto out;
}
if (header_return.header_err_flag) {
DLog("Error reading headers\n");
goto out;
}
// Sometimes, server doesn't return content-length
// if (header_return.content_length <= 0) {
// DLog("No content received from server\n");
// goto out;
// }
// lenght in Byte
long response_length = read_socket(sockfd, buffer, buffer_size, test_respond_size);
if (response_length <= 0) {
goto out;
} else {
// Calculate the interval time from start to end, and get the internet speed
struct timeval time_end;
gettimeofday(&time_end, NULL);
long miliStartSecond = (time_start.tv_sec)*1000 + (long)time_start.tv_usec/1000;
long miliEndSecond = (time_end.tv_sec)*1000 + (long)time_end.tv_usec/1000;
response_speed = response_length/((miliEndSecond - miliStartSecond)/1000.f); // "B/s"
DLog("millisecond interval: %ld , target size: %d B, response length: %ld B, response speed: %d KB/S\n", miliEndSecond - miliStartSecond, test_respond_size, response_length, response_speed/1024);
}
out:
// Close the connection down
shutdown(sockfd, SHUT_RDWR);
close(sockfd);
sockfd = -1;
return response_speed;
}
static int dosignencode(int dosign, int doencode, int dodecode,
FILE *fpin, FILE *fpout,
int argc, char **argv)
{
struct mimestack *boundary_stack=0;
int iseof=0;
while (!iseof)
{
static const char ct_s[]="content-type:";
struct header *h=read_headers(&boundary_stack, &iseof, fpin,
fpout, dodecode ? 0:1),
*hct;
if (iseof && !h)
continue; /* Artifact */
hct=find_header(h, ct_s);
/*
** If this is a multipart MIME section, we can keep on
** truckin'.
**
*/
if (hct)
{
struct mime_header *mh=
parse_mime_header(hct->header+
(sizeof(ct_s)-1));
const char *bv;
if (strcasecmp(mh->header_name, "multipart/x-mimegpg")
== 0)
{
/* Punt */
char *buf=malloc(strlen(hct->header)+100);
const char *p;
if (!buf)
{
free_mime_header(mh);
free_header(h);
perror("malloc");
exit(1);
}
strcpy(buf, "Content-Type: multipart/mixed");
p=strchr(hct->header, ';');
strcat(buf, p ? p:"");
free(hct->header);
hct->header=buf;
mh=parse_mime_header(hct->header+
sizeof(ct_s)-1);
}
if (strncasecmp(mh->header_name, "multipart/", 10)==0
&& (bv=get_mime_attr(mh, "boundary")) != 0
&& (doencode & ENCODE_ENCAPSULATE) == 0
)
{
struct header *p;
push_mimestack(&boundary_stack, bv);
if (dodecode)
{
if (strcasecmp(mh->header_name,
"multipart/signed")==0
&& (dodecode & DECODE_CHECKSIGN)
&& isgpg(mh))
{
print_noncontent_headers(h,
fpout
);
free_mime_header(mh);
checksign(&boundary_stack,
&iseof,
h, fpin, fpout,
argc, argv);
free_header(h);
continue;
}
if (strcasecmp(mh->header_name,
"multipart/encrypted")
==0
&& (dodecode & DECODE_UNENCRYPT)
&& isgpg(mh))
{
print_noncontent_headers(h,
fpout
);
free_mime_header(mh);
decrypt(&boundary_stack,
&iseof,
h,
fpin, fpout,
argc, argv);
free_header(h);
continue;
}
}
for (p=h; p; p=p->next)
{
fprintf(fpout, "%s", p->header);
}
putc('\n', fpout);
free_header(h);
free_mime_header(mh);
find_boundary(&boundary_stack, &iseof, fpin,
fpout, dodecode ? 0:1);
continue;
}
free_mime_header(mh);
}
if (dodecode)
{
struct header *p;
int is_message_rfc822=0;
for (p=h; p; p=p->next)
{
fprintf(fpout, "%s", p->header);
}
putc('\n', fpout);
/*
** If this is a message/rfc822 attachment, we can
** resume reading the next set of headers.
*/
hct=find_header(h, ct_s);
if (hct)
{
struct mime_header *mh=
parse_mime_header(hct->header+
(sizeof(ct_s)-1));
if (strcasecmp(mh->header_name,
"message/rfc822") == 0)
is_message_rfc822=1;
free_mime_header(mh);
}
free_header(h);
if (!is_message_rfc822)
find_boundary(&boundary_stack, &iseof,
fpin, fpout, 0);
continue;
}
if (doencode)
dogpgencrypt(&boundary_stack, h, &iseof,
fpin, fpout, argc, argv, dosign);
else
dogpgsign(&boundary_stack, h, &iseof,
fpin, fpout, argc, argv);
free_header(h);
}
if (ferror(fpout))
return (1);
return (0);
}
grub_err_t
SUFFIX (grub_freebsd_load_elfmodule) (struct grub_relocator *relocator,
grub_file_t file, int argc, char *argv[],
grub_addr_t *kern_end)
{
Elf_Ehdr e;
Elf_Shdr *s;
char *shdr = 0;
grub_addr_t curload, module;
grub_err_t err;
grub_size_t chunk_size = 0;
void *chunk_src;
err = read_headers (file, &e, &shdr);
if (err)
return err;
curload = module = ALIGN_PAGE (*kern_end);
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) ((char *) shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
{
if (s->sh_size == 0)
continue;
if (! (s->sh_flags & SHF_ALLOC))
continue;
if (chunk_size < s->sh_addr + s->sh_size)
chunk_size = s->sh_addr + s->sh_size;
}
if (chunk_size < sizeof (e))
chunk_size = sizeof (e);
chunk_size += e.e_phnum * e.e_phentsize;
chunk_size += e.e_shnum * e.e_shentsize;
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
module, chunk_size);
if (err)
return err;
chunk_src = get_virtual_current_address (ch);
}
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) ((char *) shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
{
if (s->sh_size == 0)
continue;
if (! (s->sh_flags & SHF_ALLOC))
continue;
grub_dprintf ("bsd", "loading section to %x, size %d, align %d\n",
(unsigned) curload, (int) s->sh_size,
(int) s->sh_addralign);
switch (s->sh_type)
{
default:
case SHT_PROGBITS:
err = load (file, (grub_uint8_t *) chunk_src + module
+ s->sh_addr - *kern_end,
s->sh_offset, s->sh_size);
if (err)
return err;
break;
case SHT_NOBITS:
grub_memset ((grub_uint8_t *) chunk_src + module
+ s->sh_addr - *kern_end, 0, s->sh_size);
break;
}
if (curload < module + s->sh_addr + s->sh_size)
curload = module + s->sh_addr + s->sh_size;
}
load (file, UINT_TO_PTR (module), 0, sizeof (e));
if (curload < module + sizeof (e))
curload = module + sizeof (e);
load (file, UINT_TO_PTR (curload), e.e_shoff,
e.e_shnum * e.e_shentsize);
e.e_shoff = curload - module;
curload += e.e_shnum * e.e_shentsize;
load (file, UINT_TO_PTR (curload), e.e_phoff,
e.e_phnum * e.e_phentsize);
e.e_phoff = curload - module;
curload += e.e_phnum * e.e_phentsize;
*kern_end = curload;
grub_freebsd_add_meta_module (argv[0], FREEBSD_MODTYPE_ELF_MODULE,
argc - 1, argv + 1, module,
curload - module);
return SUFFIX (grub_freebsd_load_elf_meta) (relocator, file, kern_end);
}
int main(int argc, char ** argv)
{
char * sender;
char * message;
unsigned int time_message;
unsigned int timer;
unsigned int num;
char * message_filename;
char * dir;
char * ptr;
char * my_delivered_to;
DIR * dirp;
struct dirent * direntp;
unsigned int message_time;
char * address;
unsigned int count;
char filename[256];
FILE * f;
unsigned int message_handling = DEFAULT_MH;
char buffer[256];
char *content_boundary;
char *rpath = DEFAULT_FROM;
char *TheUser;
char *TheDomain;
if(argc > 7 || argc < 5) {
fprintf(stderr, "\nautorespond: ");
fprintf(stderr, "usage: time num message dir [ flag arsender ]\n\n");
fprintf(stderr, "time - amount of time to consider a message (in seconds)\n");
fprintf(stderr, "num - maximum number of messages to allow within time seconds\n");
fprintf(stderr, "message - the filename of the message to send\n");
fprintf(stderr, "dir - the directory to hold the log of messages\n\n");
fprintf(stderr, "optional parameters:\n\n");
fprintf(stderr, "flag - handling of original message:\n\n");
fprintf(stderr, "0 - append nothing\n");
fprintf(stderr, "1 - append quoted original message without attachments <default>\n\n");
fprintf(stderr, "arsender - from address in generated message, or:\n\n");
fprintf(stderr, "+ = blank from envelope !\n");
fprintf(stderr, "$ = To: address will be used\n\n");
_exit(111);
}
TheUser= getenv("EXT");
TheDomain= getenv("HOST");
setvbuf(stderr, NULL, _IONBF, 0);
if(argc > 7 || argc < 5) {
fprintf(stderr, "AUTORESPOND: Invalid arguments. (%d)\n",argc);
_exit(111);
}
time_message = strtoul(argv[1],NULL,10);
num = strtoul(argv[2],NULL,10);
message_filename = argv[3];
dir = argv[4];
if ( argc > 5 )
message_handling = strtoul(argv[5],NULL,10);
if ( argc > 6 )
rpath = argv[6];
if ( *rpath == '+' )
rpath = "";
if ( *rpath == '$' )
{
rpath = safe_malloc( strlen(TheUser) + strlen(TheDomain) + 2);
strncpy( rpath, TheUser, strlen(TheUser) );
strncat( rpath, "@", 1 );
strncat( rpath, TheDomain, strlen(TheDomain) );
}
timer = time(NULL);
/*prepare the "delivered-to" string*/
my_delivered_to = "Delivered-To: Autoresponder\n";
read_headers( stdin );
message = read_file(message_filename);
if(message==NULL) {
fprintf(stderr, "AUTORESPOND: Failed to open message file.\n");
_exit(111);
}
/*don't autorespond in certain situations*/
sender = getenv("SENDER");
if(sender==NULL)
sender = "";
/*don't autorespond to a mailer-daemon*/
if( sender[0]==0 || strncasecmp(sender,"mailer-daemon",13)==0 || strchr(sender,'@')==NULL || strcmp(sender,"#@[]")==0 ) {
/*exit with success and continue parsing .qmail file*/
fprintf(stderr,"AUTORESPOND: Stopping on mail from [%s].\n",sender);
_exit(0);
}
if ( inspect_headers("mailing-list", (char *)NULL ) != (char *)NULL )
{
fprintf(stderr,"AUTORESPOND: This looks like it's from a mailing list, I will ignore it.\n");
_exit(0); /*report success and exit*/
}
if ( inspect_headers("Delivered-To", "Autoresponder" ) != (char *)NULL )
{
/*got one of my own messages...*/
fprintf(stderr,"AUTORESPOND: This message is looping...it has my Delivered-To header.\n");
_exit(100); /*hard error*/
}
if ( inspect_headers("precedence", "junk" ) != (char *)NULL ||
inspect_headers("precedence", "bulk" ) != (char *)NULL ||
inspect_headers("precedence", "list" ) != (char *)NULL )
{
fprintf(stderr,"AUTORESPOND: Junk mail received.\n");
_exit(0); /* don't reply to bulk, junk, or list mail */
}
/*check the logs*/
if(chdir(dir) == -1) {
fprintf(stderr,"AUTORESPOND: Failed to change into directory.\n");
_exit(111);
}
/*add entry*/
sprintf(filename,"A%u.%u",getpid(),timer);
f = fopen(filename,"wb");
if(f==NULL) {
fprintf(stderr,"AUTORESPOND: Unable to create file for [%s].",sender);
_exit(111);
}
if(fwrite(sender,1,strlen(sender),f)!=strlen(sender)) {
fprintf(stderr,"AUTORESPOND: Unable to create file for [%s].",sender);
fclose(f);
unlink(filename);
_exit(111);
}
fclose(f);
/*check if there are too many responses in the logs*/
dirp = opendir(".");
count = 0;
while((direntp = readdir(dirp)) != NULL) {
if(direntp->d_name[0] != 'A')
continue;
ptr = strchr(direntp->d_name,'.');
if(ptr==NULL)
continue;
message_time = strtoul(ptr+1,NULL,10);
if(message_time < timer-time_message) {
/*too old..ignore errors on unlink*/
unlink(direntp->d_name);
} else {
address = read_file(direntp->d_name);
if(address==NULL) {
/*ignore this?*/
continue;
}
if(strcasecmp(address,sender)==0) {
count++;
}
free(address);
}
}
if(count>num) {
fprintf(stderr,"AUTORESPOND: too many received from [%s]\n",sender);
_exit(0); /* don't reply to this message, but allow it to be delivered */
}
sprintf(filename,"tmp%u.%u",getpid(),timer);
f = fopen(filename,"wb");
fprintf( f, "%sTo: %s\nFrom: %s\nSubject: Re:%s\n%s\n",
my_delivered_to, sender, rpath, inspect_headers( "Subject", (char *) NULL ), message );
if ( message_handling == 1 ) {
fprintf( f, "%s\n\n", "-------- Original Message --------" );
if ( (content_boundary = get_content_boundary()) == (char *)NULL )
{
while ( fgets( buffer, sizeof(buffer), stdin ) != NULL )
{
fputs( "> ", f );
fputs( buffer, f );
}
} else
{
int content_found = 0;
while ( fgets( buffer, sizeof(buffer), stdin ) != NULL )
{
if ( content_found == 1 )
{
if ( strstr( buffer, content_boundary ) != (char *)NULL )
break;
fputs( "> ", f );
fputs( buffer, f );
}
if ( strstr( buffer, content_boundary ) != (char *)NULL )
{
if ( content_found == 1 )
break;
else
{
free_headers();
read_headers( stdin );
if ( inspect_headers("Content-Type", "text/plain" ) != (char *)NULL )
content_found = 1;
continue;
}
}
}
}
}
fprintf( f, "\n\n" );
fclose( f );
/*send the autoresponse...ignore errors?*/
send_message(filename,rpath,&sender,1);
unlink( filename );
_exit(0);
return 0; /*compiler warning squelch*/
}
grub_err_t
SUFFIX (grub_netbsd_load_elf_meta) (struct grub_relocator *relocator,
grub_file_t file, grub_addr_t *kern_end)
{
grub_err_t err;
Elf_Ehdr e;
Elf_Shdr *s, *symsh, *strsh;
char *shdr = NULL;
unsigned symsize, strsize;
void *sym_chunk;
grub_uint8_t *curload;
grub_size_t chunk_size;
Elf_Ehdr *e2;
struct grub_netbsd_btinfo_symtab symtab;
grub_addr_t symtarget;
err = read_headers (file, &e, &shdr);
if (err)
return err;
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) (shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
if (s->sh_type == SHT_SYMTAB)
break;
if (s >= (Elf_Shdr *) ((char *) shdr
+ e.e_shnum * e.e_shentsize))
return GRUB_ERR_NONE;
symsize = s->sh_size;
symsh = s;
s = (Elf_Shdr *) (shdr + e.e_shentsize * s->sh_link);
strsize = s->sh_size;
strsh = s;
chunk_size = ALIGN_UP (symsize, sizeof (grub_freebsd_addr_t))
+ ALIGN_UP (strsize, sizeof (grub_freebsd_addr_t))
+ sizeof (e) + e.e_shnum * e.e_shentsize;
symtarget = ALIGN_UP (*kern_end, sizeof (grub_freebsd_addr_t));
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
symtarget, chunk_size);
if (err)
return err;
sym_chunk = get_virtual_current_address (ch);
}
symtab.nsyms = 1;
symtab.ssyms = symtarget;
symtab.esyms = symtarget + chunk_size;
curload = sym_chunk;
e2 = (Elf_Ehdr *) curload;
grub_memcpy (curload, &e, sizeof (e));
e2->e_phoff = 0;
e2->e_phnum = 0;
e2->e_phentsize = 0;
e2->e_shstrndx = 0;
e2->e_shoff = sizeof (e);
curload += sizeof (e);
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) (shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
{
Elf_Shdr *s2;
s2 = (Elf_Shdr *) curload;
grub_memcpy (curload, s, e.e_shentsize);
if (s == symsh)
s2->sh_offset = sizeof (e) + e.e_shnum * e.e_shentsize;
else if (s == strsh)
s2->sh_offset = ALIGN_UP (symsize, sizeof (grub_freebsd_addr_t))
+ sizeof (e) + e.e_shnum * e.e_shentsize;
else
s2->sh_offset = 0;
s2->sh_addr = s2->sh_offset;
curload += e.e_shentsize;
}
if (grub_file_seek (file, symsh->sh_offset) == (grub_off_t) -1)
return grub_errno;
if (grub_file_read (file, curload, symsize) != (grub_ssize_t) symsize)
{
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_errno;
}
curload += ALIGN_UP (symsize, sizeof (grub_freebsd_addr_t));
if (grub_file_seek (file, strsh->sh_offset) == (grub_off_t) -1)
return grub_errno;
if (grub_file_read (file, curload, strsize) != (grub_ssize_t) strsize)
{
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_errno;
}
err = grub_bsd_add_meta (NETBSD_BTINFO_SYMTAB,
&symtab,
sizeof (symtab));
if (err)
return err;
*kern_end = ALIGN_PAGE (symtarget + chunk_size);
return GRUB_ERR_NONE;
}
int handle_client_connection() {
char buffer[8096];
int buffer_len; // Length of buffer
char method[256];
char url[256];
char version[256];
int i = 0, // Used to iterate over the first line to get method, url, version
j = 0;
// Read first line
buffer_len = read_line(client_sockfd, buffer, sizeof(buffer));
// Unable to read from socket, not sure what to do in this case
if (buffer_len <= 0) {
return -1;
}
fprintf(stderr, "==== Read Next Request ====\n");
// Get Method (e.g. GET, POST, etc)
while ((i < (sizeof(method) - 1)) && (!isspace(buffer[i]))) {
method[i] = buffer[i];
i++;
}
method[i] = '\0';
// fprintf(stderr, "method: %s\n", method);
// Skip over spaces
while (i < buffer_len && isspace(buffer[i])) {
i++;
}
// Get URL
j = 0;
while (i < buffer_len && (j < (sizeof(url) - 1)) && !isspace(buffer[i])) {
url[j] = buffer[i];
i++;
j++;
}
url[j] = '\0';
// fprintf(stderr, "url: %s\n", url);
// Skip over spaces
while (i < buffer_len && isspace(buffer[i])) {
i++;
}
j = 0;
while (j < sizeof(version) - 1 && !isspace(buffer[i])) {
version[j] = buffer[i];
i++;
j++;
}
version[j] = '\0';
// fprintf(stderr, "version: %s\n", version);
read_headers();
if (header_err_flag) {
keep_alive = FALSE;
bad_request();
return -1;
}
if (content_length > 0) {
content = (char*) malloc(content_length + 1);
read_socket(client_sockfd, content, content_length);
}
// fprintf(stderr, "Content-Length: %d\n", content_length);
// fprintf(stderr, "Connection (keep_alive): %d\n", keep_alive);
// fprintf(stderr, "Cookie: %d\n", cookie);
// fprintf(stderr, "If-Modified-Since Valid Time: %d\n", time_is_valid);
// fprintf(stderr, "If-Modified-Since Time: %p\n", if_modified_since);
if (content != NULL) {
// fprintf(stderr, "Content: %s\n", content);
}
/***********************************************************/
/* Full message has been read, respond to client */
/***********************************************************/
if (strcmp(method, "GET") != 0) {
// Inform client we don't support method
fprintf(stderr, "Method Not Allowed: %s\n", method);
method_not_allowed();
return 0;
}
if (cookie) {
// Inform client we don't support cookies
not_implemented();
return 0;
}
if (not_eng) {
// Inform client we only support English
not_implemented();
return 0;
}
if (!acceptable_text) {
// Inform client we only support plain text
not_implemented();
return 0;
}
if (!acceptable_charset) {
// Inform client we only support ASCII
not_implemented();
return 0;
}
// Fix filename
char file_path[512];
sprintf(file_path, "htdocs%s", url);
if (file_path[strlen(file_path)-1] == '/') {
file_path[strlen(file_path)-1] = '\0';
}
// fprintf(stderr, "%s\n", file_path);
int fname_valid = is_valid_fname(file_path);
struct stat file_info;
if (!fname_valid) {
// invalid filename
fprintf(stderr, "403 Forbidden: Invalid file name\n");
forbidden();
return 0;
}
if (stat(file_path, &file_info)) {
fprintf(stderr, "404 Not Found: Stat failed\n");
// Stat failed
not_found();
return 1;
}
if (!S_ISREG(file_info.st_mode)) {
// Not a file
forbidden();
fprintf(stderr, "403 Forbidden: Not a regular file\n");
return 0;
}
if (!(file_info.st_mode & S_IRUSR)) {
// No read permissions
forbidden();
fprintf(stderr, "403 Forbidden: No read permissions\n");
return 0;
}
FILE *f = fopen(file_path, "r");
if (f == NULL) {
// No file
not_found();
fprintf(stderr, "404 Not Found: Unable to open file\n");
return 0;
}
if (if_modified_since != NULL) {
struct tm *last_modified = gmtime(&file_info.st_mtime);
time_t last = mktime(last_modified);
time_t since = mktime(if_modified_since);
double diff = difftime(last, since);
if (diff <= 0) {
fprintf(stderr, "304 Not Modified\n");
not_modified();
return 0;
}
}
fprintf(stderr, "All looks good, serving up content in %s\n", file_path);
char *file_contents = NULL;
int contents_length = 0;
char line[512];
while (fgets(line, sizeof(line), f) != NULL) {
if (file_contents != NULL) {
char *new_contents = (char*) malloc(contents_length + strlen(line) + 1);
strcpy(new_contents, file_contents);
strcpy(new_contents + strlen(new_contents), line);
contents_length += strlen(line);
free(file_contents);
file_contents = new_contents;
} else {
file_contents = (char*) malloc(strlen(line) + 1);
strcpy(file_contents, line);
contents_length += strlen(line);
}
}
fclose(f);
// fprintf(stderr, "File Contents:\n");
// fprintf(stderr, "%s\n", file_contents);
ok(file_contents);
return 0;
}
grub_err_t
SUFFIX (grub_freebsd_load_elfmodule_obj) (struct grub_relocator *relocator,
grub_file_t file, int argc,
char *argv[], grub_addr_t *kern_end)
{
Elf_Ehdr e;
Elf_Shdr *s;
char *shdr = 0;
grub_addr_t curload, module;
grub_err_t err;
grub_size_t chunk_size = 0;
void *chunk_src;
err = read_headers (file, &e, &shdr);
if (err)
return err;
curload = module = ALIGN_PAGE (*kern_end);
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) ((char *) shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
{
if (s->sh_size == 0)
continue;
if (s->sh_addralign)
chunk_size = ALIGN_UP (chunk_size + *kern_end, s->sh_addralign)
- *kern_end;
chunk_size += s->sh_size;
}
{
grub_relocator_chunk_t ch;
err = grub_relocator_alloc_chunk_addr (relocator, &ch,
module, chunk_size);
if (err)
return err;
chunk_src = get_virtual_current_address (ch);
}
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) ((char *) shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
{
if (s->sh_size == 0)
continue;
if (s->sh_addralign)
curload = ALIGN_UP (curload, s->sh_addralign);
s->sh_addr = curload;
grub_dprintf ("bsd", "loading section to %x, size %d, align %d\n",
(unsigned) curload, (int) s->sh_size,
(int) s->sh_addralign);
switch (s->sh_type)
{
default:
case SHT_PROGBITS:
err = load (file, (grub_uint8_t *) chunk_src + curload - *kern_end,
s->sh_offset, s->sh_size);
if (err)
return err;
break;
case SHT_NOBITS:
grub_memset ((grub_uint8_t *) chunk_src + curload - *kern_end, 0,
s->sh_size);
break;
}
curload += s->sh_size;
}
*kern_end = ALIGN_PAGE (curload);
err = grub_freebsd_add_meta_module (argv[0], FREEBSD_MODTYPE_ELF_MODULE_OBJ,
argc - 1, argv + 1, module,
curload - module);
if (! err)
err = grub_bsd_add_meta (FREEBSD_MODINFO_METADATA
| FREEBSD_MODINFOMD_ELFHDR,
&e, sizeof (e));
if (! err)
err = grub_bsd_add_meta (FREEBSD_MODINFO_METADATA
| FREEBSD_MODINFOMD_SHDR,
shdr, e.e_shnum * e.e_shentsize);
return err;
}
bool proxy_connection::loop(unsigned fd)
{
size_t total = 0;
size_t count;
int error;
bool ret;
do {
logger::instance().log(logger::LOG_DEBUG, "[proxy_connection::loop] (fd %d) State = %s.", fd, state_to_string(_M_state));
switch (_M_state) {
case CONNECTING_STATE:
if (!_M_client) {
return false;
}
if ((!socket_wrapper::get_socket_error(fd, error)) || (error)) {
logger::instance().log(logger::LOG_WARNING, "(fd %d) Connection to backend failed with error: %d.", fd, error);
#if !PROXY
_M_client->_M_rule->backends.connection_failed(fd);
#endif
_M_client->_M_error = http_error::GATEWAY_TIMEOUT;
_M_state = PREPARING_ERROR_PAGE_STATE;
} else {
if (!_M_client->_M_payload_in_memory) {
socket_wrapper::cork(fd);
}
_M_state = SENDING_HEADERS_STATE;
}
break;
case SENDING_HEADERS_STATE:
if (!_M_writable) {
return true;
}
if ((!_M_client->_M_payload_in_memory) || (_M_client->_M_request_body_size == 0)) {
count = _M_out.count();
ret = write(fd, total);
} else {
socket_wrapper::io_vector io_vector[2];
io_vector[0].iov_base = _M_out.data();
io_vector[0].iov_len = _M_out.count();
io_vector[1].iov_base = _M_client->_M_in.data() + _M_client->_M_request_header_size;
io_vector[1].iov_len = _M_client->_M_request_body_size;
count = io_vector[0].iov_len + io_vector[1].iov_len;
ret = writev(fd, io_vector, 2, total);
}
if (!ret) {
_M_client->_M_error = http_error::GATEWAY_TIMEOUT;
_M_state = PREPARING_ERROR_PAGE_STATE;
} else {
_M_client->_M_timestamp = now::_M_time;
if (_M_outp == (off_t) count) {
if (_M_client->_M_payload_in_memory) {
if (!modify(fd, tcp_server::READ)) {
_M_client->_M_error = http_error::INTERNAL_SERVER_ERROR;
_M_state = PREPARING_ERROR_PAGE_STATE;
} else {
_M_client->_M_body.reset();
_M_state = READING_STATUS_LINE_STATE;
}
} else {
_M_outp = 0;
_M_state = SENDING_BODY_STATE;
}
}
}
break;
case SENDING_BODY_STATE:
if (!_M_writable) {
return true;
}
if (!sendfile(fd, _M_client->_M_tmpfile, _M_client->_M_request_body_size, total)) {
_M_client->_M_error = http_error::GATEWAY_TIMEOUT;
_M_state = PREPARING_ERROR_PAGE_STATE;
} else {
_M_client->_M_timestamp = now::_M_time;
if (_M_outp == (off_t) _M_client->_M_request_body_size) {
// We don't need the client's temporary file anymore.
static_cast<http_server*>(_M_server)->_M_tmpfiles.close(_M_client->_M_tmpfile);
_M_client->_M_tmpfile = -1;
socket_wrapper::uncork(fd);
if (!modify(fd, tcp_server::READ)) {
_M_client->_M_error = http_error::INTERNAL_SERVER_ERROR;
_M_state = PREPARING_ERROR_PAGE_STATE;
} else {
_M_client->_M_body.reset();
_M_state = READING_STATUS_LINE_STATE;
}
}
}
break;
case READING_STATUS_LINE_STATE:
if (!_M_readable) {
return true;
}
if (!read_status_line(fd, total)) {
_M_state = PREPARING_ERROR_PAGE_STATE;
}
break;
case READING_HEADERS_STATE:
if (!_M_readable) {
return true;
}
if (!read_headers(fd, total)) {
_M_state = PREPARING_ERROR_PAGE_STATE;
}
break;
case PROCESSING_RESPONSE_STATE:
if (!process_response(fd)) {
_M_state = PREPARING_ERROR_PAGE_STATE;
}
break;
case READING_BODY_STATE:
if (!_M_readable) {
return true;
}
if (!read_body(fd, total)) {
_M_state = PREPARING_ERROR_PAGE_STATE;
}
break;
case READING_CHUNKED_BODY_STATE:
if (!_M_readable) {
return true;
}
if (!read_chunked_body(fd, total)) {
_M_state = PREPARING_ERROR_PAGE_STATE;
}
break;
case READING_UNKNOWN_SIZE_BODY_STATE:
if (!_M_readable) {
return true;
}
if (!read_unknown_size_body(fd, total)) {
_M_state = PREPARING_ERROR_PAGE_STATE;
}
break;
case PREPARING_ERROR_PAGE_STATE:
if (!http_error::build_page(_M_client)) {
return false;
}
_M_client->_M_response_header_size = _M_client->_M_out.count();
if ((_M_client->_M_method == http_method::HEAD) || (_M_client->_M_bodyp->count() == 0)) {
_M_client->_M_filesize = 0;
} else {
_M_client->_M_filesize = _M_client->_M_bodyp->count();
}
_M_client->_M_payload_in_memory = 1;
_M_client->_M_in_ready_list = 1;
_M_client->_M_state = http_connection::SENDING_BACKEND_HEADERS_STATE;
return false;
case RESPONSE_COMPLETED_STATE:
if (!prepare_http_response(fd)) {
_M_client->_M_error = http_error::INTERNAL_SERVER_ERROR;
_M_state = PREPARING_ERROR_PAGE_STATE;
} else {
_M_client->_M_in_ready_list = 1;
_M_client->_M_tmpfile = _M_tmpfile;
_M_tmpfile = -1;
_M_client->_M_state = http_connection::SENDING_BACKEND_HEADERS_STATE;
if (!_M_client->_M_payload_in_memory) {
socket_wrapper::cork(_M_fd);
}
return false;
}
break;
}
} while (!_M_in_ready_list);
return true;
}
static void checksign(struct mimestack **stack, int *iseof,
struct header *h,
FILE *fpin, FILE *fpout,
int argc, char **argv)
{
char buf[BUFSIZ];
struct header *h2;
char signed_content[TEMPNAMEBUFSIZE];
char signature[TEMPNAMEBUFSIZE];
int signed_file, signature_file;
FILE *signed_file_fp, *signature_file_fp;
int clos_flag;
int need_nl, check_boundary;
struct mimestack *b=0;
struct mime_header *mh;
int qpdecode=0;
signed_file=mimegpg_tempfile(signed_content);
if (signed_file < 0 || (signed_file_fp=fdopen(signed_file, "w+")) == 0)
{
if (signed_file > 0)
{
close(signed_file);
unlink(signed_content);
}
perror("open");
exit(1);
}
noexec(signed_file_fp);
find_boundary(stack, iseof, fpin, NULL, 0);
if (*iseof)
return;
need_nl=0;
check_boundary=1;
while (!*iseof)
{
const char *p;
if (fgets(buf, sizeof(buf), fpin) == NULL)
{
*iseof=1;
continue;
}
if (check_boundary
&& (b=is_boundary(*stack, buf, &clos_flag)) != 0)
break;
if (need_nl)
fprintf(signed_file_fp, "\r\n");
for (p=buf; *p && *p != '\n'; p++)
putc(*p, signed_file_fp);
need_nl=check_boundary= *p != 0;
}
if (my_rewind(signed_file_fp) < 0)
{
perror(signed_content);
fclose(signed_file_fp);
unlink(signed_content);
exit(1);
}
if (clos_flag)
{
fclose(signed_file_fp);
unlink(signed_content);
if (b)
pop_mimestack_to(stack, b);
find_boundary(stack, iseof, fpin, fpout, 1);
return;
}
h=read_headers(stack, iseof, fpin, fpout, 0);
if (!h || !(h2=find_header(h, "content-type:")))
{
fclose(signed_file_fp);
unlink(signed_content);
if (!*iseof)
find_boundary(stack, iseof, fpin, fpout, 1);
return;
}
mh=parse_mime_header(h2->header+sizeof("content-type:")-1);
if (!mh)
{
perror("malloc");
free_header(h);
fclose(signed_file_fp);
unlink(signed_content);
exit(1);
}
if (!mh || strcasecmp(mh->header_name, "application/pgp-signature"))
{
if (!mh)
free_mime_header(mh);
free_header(h);
fclose(signed_file_fp);
unlink(signed_content);
if (!*iseof)
find_boundary(stack, iseof, fpin, fpout, 1);
return;
}
free_mime_header(mh);
/*
** In rare instances, the signature is qp-encoded.
*/
if ((h2=find_header(h, "content-transfer-encoding:")) != NULL)
{
mh=parse_mime_header(h2->header
+sizeof("content-transfer-encoding:")-1);
if (!mh)
{
perror("malloc");
free_header(h);
fclose(signed_file_fp);
unlink(signed_content);
exit(1);
}
if (strcasecmp(mh->header_name,
"quoted-printable") == 0)
qpdecode=1;
free_mime_header(mh);
}
free_header(h);
signature_file=mimegpg_tempfile(signature);
if (signature_file < 0
|| (signature_file_fp=fdopen(signature_file, "w+")) == 0)
{
if (signature_file > 0)
{
close(signature_file);
unlink(signature);
}
fclose(signed_file_fp);
unlink(signed_content);
perror("open");
exit(1);
}
while (!*iseof)
{
const char *p;
if (fgets(buf, sizeof(buf), fpin) == NULL)
{
*iseof=1;
continue;
}
if ((b=is_boundary(*stack, buf, &clos_flag)) != 0)
break;
for (p=buf; *p; p++)
{
int n;
if (!qpdecode)
{
putc(*p, signature_file_fp);
continue;
}
if (*p == '=' && p[1] == '\n')
break;
if (*p == '=' && p[1] && p[2])
{
n=nybble(p[1]) * 16 + nybble(p[2]);
if ( (char)n )
{
putc((char)n, signature_file_fp);
p += 2;
}
p += 2;
continue;
}
putc(*p, signature_file_fp);
/* If some spits out qp-lines > BUFSIZ, they deserve
** this crap.
*/
}
}
fflush(signature_file_fp);
if (ferror(signature_file_fp) || fclose(signature_file_fp))
{
unlink(signature);
fclose(signed_file_fp);
unlink(signed_content);
perror("open");
exit(1);
}
dochecksign(*stack, signed_file_fp, fpout, signed_content, signature,
argc, argv);
fclose(signed_file_fp);
unlink(signature);
unlink(signed_content);
fprintf(fpout, "\n--%s--\n", b->boundary);
while (!clos_flag)
{
if (fgets(buf, sizeof(buf), fpin) == NULL)
{
*iseof=1;
break;
}
if (!(b=is_boundary(*stack, buf, &clos_flag)))
clos_flag=0;
}
if (b)
pop_mimestack_to(stack, b);
if (iseof)
return;
}
grub_err_t
SUFFIX (grub_freebsd_load_elf_meta) (grub_file_t file, grub_addr_t *kern_end)
{
grub_err_t err;
Elf_Ehdr e;
Elf_Shdr *s;
char *shdr;
unsigned symoff, stroff, symsize, strsize;
grub_addr_t curload;
grub_freebsd_addr_t symstart, symend, symentsize, dynamic;
Elf_Sym *sym;
const char *str;
unsigned i;
err = read_headers (file, &e, &shdr);
if (err)
return err;
err = grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_ELFHDR, &e,
sizeof (e));
if (err)
return err;
for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) (shdr
+ e.e_shnum * e.e_shentsize);
s = (Elf_Shdr *) ((char *) s + e.e_shentsize))
if (s->sh_type == SHT_SYMTAB)
break;
if (s >= (Elf_Shdr *) ((char *) shdr
+ e.e_shnum * e.e_shentsize))
return grub_error (GRUB_ERR_BAD_OS, "no symbol table");
symoff = s->sh_offset;
symsize = s->sh_size;
symentsize = s->sh_entsize;
s = (Elf_Shdr *) (shdr + e.e_shentsize * s->sh_link);
stroff = s->sh_offset;
strsize = s->sh_size;
if (*kern_end + 4 * sizeof (grub_freebsd_addr_t) + symsize + strsize
> grub_os_area_addr + grub_os_area_size)
return grub_error (GRUB_ERR_OUT_OF_RANGE,
"not enough memory for kernel symbols");
symstart = curload = ALIGN_UP (*kern_end, sizeof (grub_freebsd_addr_t));
*((grub_freebsd_addr_t *) UINT_TO_PTR (curload)) = symsize;
curload += sizeof (grub_freebsd_addr_t);
if (grub_file_seek (file, symoff) == (grub_off_t) -1)
return grub_errno;
sym = (Elf_Sym *) UINT_TO_PTR (curload);
if (grub_file_read (file, UINT_TO_PTR (curload), symsize) !=
(grub_ssize_t) symsize)
{
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_errno;
}
curload += symsize;
*((grub_freebsd_addr_t *) UINT_TO_PTR (curload)) = strsize;
curload += sizeof (grub_freebsd_addr_t);
if (grub_file_seek (file, stroff) == (grub_off_t) -1)
return grub_errno;
str = (char *) UINT_TO_PTR (curload);
if (grub_file_read (file, UINT_TO_PTR (curload), strsize)
!= (grub_ssize_t) strsize)
{
if (! grub_errno)
return grub_error (GRUB_ERR_BAD_OS, "invalid ELF");
return grub_errno;
}
curload += strsize;
curload = ALIGN_UP (curload, sizeof (grub_freebsd_addr_t));
symend = curload;
for (i = 0;
i * symentsize < symsize;
i++, sym = (Elf_Sym *) ((char *) sym + symentsize))
{
const char *name = str + sym->st_name;
if (grub_strcmp (name, "_DYNAMIC") == 0)
break;
}
if (i * symentsize < symsize)
{
dynamic = sym->st_value;
grub_dprintf ("bsd", "dynamic = %llx\n", (unsigned long long) dynamic);
err = grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_DYNAMIC, &dynamic,
sizeof (dynamic));
if (err)
return err;
}
err = grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_SSYM, &symstart,
sizeof (symstart));
if (err)
return err;
err = grub_freebsd_add_meta (FREEBSD_MODINFO_METADATA |
FREEBSD_MODINFOMD_ESYM, &symend,
sizeof (symend));
if (err)
return err;
*kern_end = ALIGN_PAGE (curload);
return GRUB_ERR_NONE;
}
