/* * Recieves HTTP request from a client connected over socket and sends * back requested resource. */ static int respond(int socket) { char rec_msg[99999]; char* request[3]; char* reqline; int bytes_rec, bytes_sent; memset(rec_msg, 0, sizeof(rec_msg)); bytes_rec = recv(socket, rec_msg, sizeof(rec_msg), 0); printf("Msg: %d\n%s\n", bytes_rec, rec_msg); reqline = strtok(rec_msg, "\n"); request[0] = strtok(reqline, " \t"); request[1] = strtok(NULL, " \t"); request[2] = strtok(NULL, " \t"); char* http10 = "HTTP/1.0"; char* http11 = "HTTP/1.1"; if (strncmp(request[2], http10, strlen(http10)) != 0 && strncmp(request[2], http11, strlen(http11)) != 0) { bytes_sent = send_all(socket, "HTTP/1.0 400 Bad Request\n"); } else { printf("Request type: %s\n", request[0]); if (strncmp(request[0], "GET", 3) == 0) { get_req(socket, request[1]); } else { bytes_sent = send_all(socket, "Only supports GET\n"); } } return bytes_sent; }
static void main_loop () { DDEV_REQ req; /* 受信する要求パケット */ ER err; extern ER sys_errno; /* * 要求受信 - 処理のループ */ for (;;) { W rsize; /* 要求の受信 */ /* dbg_printf ("call get_req ()\n"); */ rsize = sizeof (req); get_req (recvport, &req, &rsize); switch (sys_errno) { case E_OK: /* 正常ケース */ /* dbg_printf ("console: receive packet type = %d\n", req.header.msgtyp); /* */ doit (&req); break; default: /* Unknown error */ dbg_printf ("CONSOLE: get_req() Unknown error(error = %d)\n", err); break; } } /* ここの行には、来ない */ }
static int send_inquiry_cmd(struct scsi_device *sdev, int page, struct clariion_dh_data *csdev) { struct request *rq = get_req(sdev, INQUIRY, csdev->buffer); int err; if (!rq) return SCSI_DH_RES_TEMP_UNAVAIL; rq->sense = csdev->sense; memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE); rq->sense_len = csdev->senselen = 0; rq->cmd[0] = INQUIRY; if (page != 0) { rq->cmd[1] = 1; rq->cmd[2] = page; } err = blk_execute_rq(sdev->request_queue, NULL, rq, 1); if (err == -EIO) { sdev_printk(KERN_INFO, sdev, "%s: failed to send %s INQUIRY: %x\n", CLARIION_NAME, page?"EVPD":"standard", rq->errors); csdev->senselen = rq->sense_len; err = SCSI_DH_IO; } blk_put_request(rq); return err; }
/* * プロセスマネージャの main 関数。 * */ int _main (void) { pm_msg_t request; init_process_manager (); banner (); /* * メッセージの受信 - 処理 - 返答のループ */ for (;;) { /* メッセージの受信 (get_req は libkernel.a にある関数) */ if (get_req (recvport, &request, sizeof (request)) > 0) { /* * リクエストの処理:返答も doit() で行う。 */ doit (&request); } else { /* * 受信でエラーとなった。 * エラーとなった原因を reject して、次の要求を受けつける。 */ } } /* DO NOT REACHED */ }
static void smd_try_to_send(struct diag_context *ctxt) { if (ctxt->ch) { int r = smd_read_avail(ctxt->ch); if (r > RXN_MAX) { printk(KERN_ERR "The SMD data is too large to send (%d) !!\n", r); // return; r = RXN_MAX; } if (r > 0) { struct diag_request *req = get_req(ctxt, &ctxt->rx_arm9_idle); if (!req) { printk(KERN_ERR "There is no enough request to ARM11!!\n"); return; } smd_read(ctxt->ch, req->buf, r); smd_xfer_count_func(r, data_set_rx); //req->length = r; //printk(KERN_ERR "ARM9 data to ARM11 %s\n", (char *)req->buf); req->actual = r; put_req(ctxt, &ctxt->rx_arm9_done, req); wake_up(&ctxt->read_arm9_wq); } } }
int add_write(const char *fname, const char *buf, int size, char flags, function_to_call_t *fun) { if (fname) { aiob *aio = get_aiob(); memset(aio, 0, sizeof(aiob)); int fd = open(fname, flags & 1 ? O_CREAT|O_WRONLY : O_CREAT|O_WRONLY|O_APPEND, S_IRWXU|S_IRWXG); aio->aio_fildes = fd; aio->aio_buf = buf; aio->aio_nbytes = size; struct request *req = get_req(); req->aio = aio; req->fun = fun; req->type = awrite; assign_svalue_no_free(&req->tmp, sp-2); add_req(req); #ifdef PACKAGE_COMPRESS if(flags & 2) return aio_gzwrite(aio); else #endif return aio_write(aio); } else error("permission denied\n"); return 1; }
int add_db_exec(int handle, function_to_call_t *fun) { struct request *req = get_req(); req->fun = fun; req->type = adbexec; req->buf = (char *)handle; assign_svalue_no_free(&req->tmp, sp-1); return aio_db_exec(req); }
static int send_cmd(struct scsi_device *sdev, int cmd) { struct request *rq = get_req(sdev, cmd); if (!rq) return SCSI_DH_RES_TEMP_UNAVAIL; return blk_execute_rq(sdev->request_queue, NULL, rq, 1); }
int add_getdir(const char *fname, function_to_call_t *fun) { if (fname) { //printf("fname: %s\n", fname); struct request *req = get_req(); req->buf = (char *)MALLOC(sizeof(struct dirent) * max_array_size); req->size = sizeof(struct dirent) * max_array_size; req->fun = fun; req->type = agetdir; strcpy(req->path, fname); return aio_getdir(req); }else error("permission denied\n"); return 1; }
static int send_trespass_cmd(struct scsi_device *sdev, struct clariion_dh_data *csdev) { struct request *rq; unsigned char *page22; int err, len, cmd; if (csdev->flags & CLARIION_SHORT_TRESPASS) { page22 = short_trespass; if (!(csdev->flags & CLARIION_HONOR_RESERVATIONS)) /* Set Honor Reservations bit */ page22[6] |= 0x80; len = sizeof(short_trespass); cmd = MODE_SELECT; } else { page22 = long_trespass; if (!(csdev->flags & CLARIION_HONOR_RESERVATIONS)) /* Set Honor Reservations bit */ page22[10] |= 0x80; len = sizeof(long_trespass); cmd = MODE_SELECT_10; } BUG_ON((len > CLARIION_BUFFER_SIZE)); memcpy(csdev->buffer, page22, len); rq = get_req(sdev, cmd, csdev->buffer); if (!rq) return SCSI_DH_RES_TEMP_UNAVAIL; rq->sense = csdev->sense; memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE); rq->sense_len = csdev->senselen = 0; err = blk_execute_rq(sdev->request_queue, NULL, rq, 1); if (err == -EIO) { if (rq->sense_len) { err = trespass_endio(sdev, csdev->sense); } else { sdev_printk(KERN_INFO, sdev, "%s: failed to send MODE SELECT: %x\n", CLARIION_NAME, rq->errors); } } blk_put_request(rq); return err; }
void* thread_consumer() { req_t req_d; int ressz, req_i; snfs_msg_res_t res; while(1) { sthread_monitor_enter(mon); // get request from queue while (!available_reqs) sthread_monitor_wait(mon); req_d = get_req(); available_reqs--; sthread_monitor_signal(mon); sthread_monitor_exit(mon); // clean response memset(&res,0,sizeof(res)); // find request handler req_i = -1; for (int i = 0; i < NUM_REQ_HANDLERS; i++) { if (req_d->req.type == Service[i].type) { req_i = i; break; } } // serve the request if (req_i == -1) { res.status = RES_UNKNOWN; ressz = sizeof(res) - sizeof(res.body); printf("[snfs_srv] unknown request.\n"); } else { Service[req_i].handler(&(req_d->req),req_d->reqsz,&res,&ressz); } // send response to client srv_send_response(&res,ressz,&(req_d->cliaddr),req_d->clilen); // free stuff free(req_d); req_d = NULL; // force request processing sthread_yield(); } }
int add_read(const char *fname, function_to_call_t *fun) { if (fname) { struct request *req = get_req(); //printf("fname: %s\n", fname); req->buf = (char *)MALLOC(READ_FILE_MAX_SIZE); req->size = READ_FILE_MAX_SIZE; req->fun = fun; req->type = aread; strcpy(req->path, fname); #ifdef PACKAGE_COMPRESS return aio_gzread(req); #else return aio_read(req); #endif }else error("permission denied\n"); return 1; }
int add_getdir(const char *fname, function_to_call_t *fun) { if (fname) { aiob *aio= get_aiob(); memset(aio, 0, sizeof(aiob)); //printf("fname: %s\n", fname); int fd = open(fname, O_RDONLY); aio->aio_fildes = fd; aio->aio_buf = (char *)MALLOC(sizeof(struct dirent) * max_array_size); aio->aio_nbytes = sizeof(struct dirent) * max_array_size; struct request *req = get_req(); req->aio = aio; req->fun = fun; req->type = agetdir; add_req(req); return aio_getdir(aio); }else error("permission denied\n"); return 1; }
static void diag_unbind(void *_ctxt) { struct diag_context *ctxt = _ctxt; struct diag_request *req; printk(KERN_DEBUG "diag_unbind()\n"); smd_xfer_count_func(0,data_set_clear); while ((req = get_req(ctxt, &ctxt->rx_arm9_idle))) { kfree(req->buf); kfree(req); } ctxt->online = 0; ctxt->error = 1; /* readers may be blocked waiting for us to go online */ wake_up(&ctxt->read_arm9_wq); }
int add_write(const char *fname, const char *buf, int size, char flags, function_to_call_t *fun) { if (fname) { struct request *req = get_req(); req->buf = buf; req->size = size; req->fun = fun; req->type = awrite; req->flags = flags; strcpy(req->path, fname); assign_svalue_no_free(&req->tmp, sp-2); #ifdef PACKAGE_COMPRESS if(flags & 2) return aio_gzwrite(req); else #endif return aio_write(req); } else error("permission denied\n"); return 1; }
static int diag2arm9_release(struct inode *ip, struct file *fp) { struct diag_context *ctxt = &_context; struct diag_request *req; DBG_OP("+%s\n", __func__); diag_configure(0, ctxt); msm_diag_smd_close(); /* recycle unhandled rx reqs to user if any */ while ((req = get_req(ctxt, &ctxt->rx_arm9_done))) put_req(ctxt, &ctxt->rx_arm9_idle, req); /* Release readers that might be blocked */ wake_up(&ctxt->read_arm9_wq); _unlock(&ctxt->open_arm9_excl); DBG_OP("-%s\n", __func__); return 0; }
int add_read(const char *fname, function_to_call_t *fun) { if (fname) { aiob *aio = get_aiob(); memset(aio, 0, sizeof(aiob)); //printf("fname: %s\n", fname); int fd = open(fname, O_RDONLY); aio->aio_fildes = fd; aio->aio_buf = (char *)MALLOC(READ_FILE_MAX_SIZE); aio->aio_nbytes = READ_FILE_MAX_SIZE; struct request *req = get_req(); req->aio = aio; req->fun = fun; req->type = aread; add_req(req); #ifdef PACKAGE_COMPRESS return aio_gzread(aio); #else return aio_read(aio); #endif }else error("permission denied\n"); return 1; }
static int parse_req(int argc, char **argv) { int idx; uint8_t rt = 0; for (idx = 0; argc != 0 && idx <= 6; argc--, idx++) switch (idx) { case 0: /* dir[ection]: i[n] | o[ut] */ if (*argv[idx] == 'i') rt |= 0x80; else if (*argv[idx] == 'o') /* nop */; else { fprintf(stderr, "request direction must be \"in\" or \"out\" (got %s)\n", argv[idx]); return -1; } break; case 1: /* type: s[tandard] | c[lass] | v[endor] */ if (*argv[idx] == 's') /* nop */; else if (*argv[idx] == 'c') rt |= 0x20; else if (*argv[idx] == 'v') rt |= 0x40; else { fprintf(stderr, "request type must be one of \"standard\", \"class\", or \"vendor\" (got %s)\n", argv[idx]); return -1; } break; case 2: /* rcpt: d[evice], i[nterface], e[ndpoint], o[ther] */ if (*argv[idx] == 'd') /* nop */; else if (*argv[idx] == 'i') rt |= 1; else if (*argv[idx] == 'e') rt |= 2; else if (*argv[idx] == 'o') rt |= 3; else { fprintf(stderr, "recipient must be one of \"device\", \"interface\", \"endpoint\", or \"other\" (got %s)\n", argv[idx]); return -1; } setup.bmRequestType = rt; break; case 3: setup.bRequest = get_req(argv[idx]); break; case 4: setup.wValue = strtoul(argv[idx], 0, 0); break; case 5: setup.wIndex = strtoul(argv[idx], 0, 0); break; case 6: setup.wLength = strtoul(argv[idx], 0, 0); break; } return argc; }
static ssize_t diag2arm9_read(struct file *fp, char __user *buf, size_t count, loff_t *pos) { struct diag_context *ctxt = &_context; struct diag_request *req; int r = 0, xfer; int ret; //ctxt->isRead = 1; DBG("diag2arm9_read(%d)\n", count); if (_lock(&ctxt->read_arm9_excl)) return -EBUSY; /* we will block until we're offline */ /* while (ctxt->online) { ret = wait_event_interruptible(ctxt->read_arm9_wq, !(ctxt->online)); if (ret < 0) { _unlock(&ctxt->read_arm9_excl); return ret; } } */ while (count > 0) { /* if (ctxt->error) { r = -EIO; break; } */ /* if we have idle read requests, get them queued */ /* while ((req = get_req(ctxt, &ctxt->rx_idle))) { requeue_req: req->length = TXN_MAX; ret = usb_ept_queue_xfer(ctxt->out, req); if (ret < 0) { DBG("diag_read: failed to queue req %p (%d)\n", req, ret); r = -EIO; ctxt->error = 1; put_req(ctxt, &ctxt->rx_idle, req); goto fail; } else { DBG("rx %p queue\n", req); } } */ /* if we have data pending, give it to userspace */ if (ctxt->read_arm9_count > 0) { xfer = (ctxt->read_arm9_count < count) ? ctxt->read_arm9_count : count; if (copy_to_user(buf, ctxt->read_arm9_buf, xfer)) { DBG("diag: copy_to_user fail\n"); r = -EFAULT; break; } ctxt->read_arm9_buf += xfer; ctxt->read_arm9_count -= xfer; buf += xfer; count -= xfer; r += xfer; /* if we've emptied the buffer, release the request */ if (ctxt->read_arm9_count == 0) { put_req(ctxt, &ctxt->rx_arm9_idle, ctxt->read_arm9_req); ctxt->read_arm9_req = 0; } continue; } /* wait for a request to complete */ req = 0; ret = wait_event_interruptible(ctxt->read_arm9_wq, ((req = get_req(ctxt, &ctxt->rx_arm9_done)) || ctxt->error)); if (req != 0) { /* if we got a 0-len one we need to put it back into ** service. if we made it the current read req we'd ** be stuck forever */ if (req->actual == 0) { // goto requeue_req; put_req(ctxt, &ctxt->rx_arm9_idle, req); continue; } ctxt->read_arm9_req = req; ctxt->read_arm9_count = req->actual; ctxt->read_arm9_buf = req->buf; if (ctxt->read_arm9_count < count) count = ctxt->read_arm9_count; DBG("rx %p %d\n", req, req->actual); } if (ret < 0) { DBG_OP("%s: ret < 0\n", __func__); r = ret; break; } } //fail: _unlock(&ctxt->read_arm9_excl); //ctxt->isRead = 0; return r; }
// Attempt to get html page from http server. bool project3::Http::httpGetRawHtml(const std::vector<std::string> &token, std::vector<unsigned char> &raw_html) { bool ret = false; if(token.empty() && token[0].empty()) { #if DEBUG == 1 Logger::instance().log("URI cannot be empty.", project3::Logger::m_logLevelError); #endif return ret; } std::string url; if(token[1].empty()) { url = "http://"; url.append(token[0]); } else { url = token[0]; } // Prepare GET request. std::string get_req("GET "); get_req.append(url); get_req.append(" HTTP/1.0 \r\n\r\n"); // Send GET request. int bytes_sent; if((bytes_sent = send(m_sockfd, get_req.c_str(), get_req.length(), 0)) < 0) { #if DEBUG == 1 std::string err_msg; if(ECONNRESET == errno) { err_msg = "The connection was reset by the server."; } else if(EINTR == errno) { err_msg = "An interrupt signal occured."; } else if(EINVAL == errno) { err_msg = "Invalid argument passed."; } else if(ENOTCONN == errno) { err_msg = "The socket is not connected."; } else if(ENOMEM == errno) { err_msg = "No memory available."; } Logger::instance().log(err_msg, project3::Logger::m_logLevelError); #endif return ret; } // Get default socket SO_RCVBUF size. int sock_rcvbufval; unsigned int sock_rcvbufvalsze = sizeof(sock_rcvbufval); getsockopt(m_sockfd, SOL_SOCKET, SO_RCVBUF, &sock_rcvbufval, &sock_rcvbufvalsze); // Store receiving data to local copy vector. std::vector<unsigned char> buf(RCV_BUF_SZE, '0'); int bytes_recv; int total_bytes_recv = 0; // Begin receiving data from http server. while(true) { if((bytes_recv = recv(m_sockfd, &(buf)[0], buf.size(), MSG_WAITALL)) < 0) { #if DEBUG == 1 std::string err_msg; if(ECONNREFUSED == errno) { err_msg = "The web server is not listening on port number 80."; } else if(EINTR == errno) { err_msg = "An interrupt occured while receiving packets."; } Logger::instance().log(err_msg, project3::Logger::m_logLevelError); #endif return ret; } else if(bytes_recv == 0) { break; } else { total_bytes_recv += bytes_recv; // Make exclusive copy of retruned http character stream for this object. std::copy(buf.cbegin(), buf.cend(), std::back_inserter(raw_html)); } } // Resize caller char vector. raw_html.resize(total_bytes_recv); // The GET request was successful. return true; }
static ssize_t diag2arm9_read(struct file *fp, char __user *buf, size_t count, loff_t *pos) { struct diag_context *ctxt = &_context; struct diag_request *req; int r = 0, xfer; int ret; DBG("diag2arm9_read(%d)\n", count); if (_lock(&ctxt->read_arm9_excl)) return -EBUSY; while (count > 0) { /* if we have data pending, give it to userspace */ if (ctxt->read_arm9_count > 0) { xfer = (ctxt->read_arm9_count < count) ? ctxt->read_arm9_count : count; if (copy_to_user(buf, ctxt->read_arm9_buf, xfer)) { DBG("diag: copy_to_user fail\n"); r = -EFAULT; break; } ctxt->read_arm9_buf += xfer; ctxt->read_arm9_count -= xfer; buf += xfer; count -= xfer; r += xfer; /* if we've emptied the buffer, release the request */ if (ctxt->read_arm9_count == 0) { put_req(ctxt, &ctxt->rx_arm9_idle, ctxt->read_arm9_req); ctxt->read_arm9_req = 0; } continue; } /* wait for a request to complete */ req = 0; ret = wait_event_interruptible(ctxt->read_arm9_wq, ((req = get_req(ctxt, &ctxt->rx_arm9_done)) || ctxt->error)); if (req != 0) { /* if we got a 0-len one we need to put it back into ** service. if we made it the current read req we'd ** be stuck forever */ if (req->actual == 0) { put_req(ctxt, &ctxt->rx_arm9_idle, req); continue; } ctxt->read_arm9_req = req; ctxt->read_arm9_count = req->actual; ctxt->read_arm9_buf = req->buf; if (ctxt->read_arm9_count < count) count = ctxt->read_arm9_count; DBG("rx %p %d\n", req, req->actual); } if (ret < 0) { DBG_OP("%s: ret < 0\n", __func__); r = ret; break; } } _unlock(&ctxt->read_arm9_excl); return r; }
void MediaThread::run() { const char *url = url_.c_str(); ic_ = 0; int rc = avformat_open_input(&ic_, url, 0, 0); if (rc < 0) { fprintf(stderr, "ERR: avformat_open_input can't open %s\n", url); return; } rc = avformat_find_stream_info(ic_, 0); if (rc < 0) { fprintf(stderr, "ERR: avformat_find_stream_info fault!\n"); avformat_close_input(&ic_); return; } av_dump_format(ic_, -1, url, 0); for (int i = 0; i < ic_->nb_streams; i++) { AVCodecContext *ctx = ic_->streams[i]->codec; AVCodec *codec = avcodec_find_decoder(ctx->codec_id); if (!codec) { fprintf(stderr, "ERR: avcodec_find_decoder NOT find %d\n", ctx->codec_id); avformat_close_input(&ic_); return; } avcodec_open2(ctx, codec, 0); } bool err = false; AVFrame *frame = av_frame_alloc(); while (1) { int code; if (chk_req(0, &code)) { if (code == 0) { reply(0); break; } } if (err) { code = get_req(); if (code == 0) { reply(0); break; } } else { AVPacket pkg; rc = av_read_frame(ic_, &pkg); if (rc < 0) { err = true; continue; } int got; do { got = decode_frame(frame, &pkg); if (got) { dr_->save_video_frame(frame); } } while (got); av_free_packet(&pkg); } } avformat_close_input(&ic_); av_frame_free(&frame); }