STSStatus request_perform(RequestParams* params, int* httpResponseCode, char* response)
{
Request* request = 0;
STSStatus status;
if (STSStatusOK != (status = request_get(params, &request))) {
fprintf(stderr, "Request Get ERR\n");
return status;
}
request->getResultCallback = responseCallback;
request->callbackData = response;
request->status = STSStatusWaiting;
CURLcode code = curl_easy_perform(request->curl);
if (CURLE_OK != code) {
request->httpResponseCode = 0;
*httpResponseCode = request->httpResponseCode;
request->status = request_curl_code_to_status(code);
return request->status;
}
else {
*httpResponseCode = request->httpResponseCode;
request_finish(request);
return request->status;
}
}
int main(int argc, char *argv[])
{
if(argc > 1){
if(argc == 3){
// as normal program, not cgi now
printf("update dns, domain: %s, host: %s\n", argv[1], argv[2]);
int ret = dns_update(argv[1], argv[2]);
if(ret < 0){
printf("Internal error.\n");
}else if(ret == 1){
printf("Recorde can't find.\n");
}else if(ret == 2){
printf("Recorde still fresh.\n");
}else if(ret == 0){
printf("Recorde refreshed.\n");
}else{
printf("Unknown error.\n");
}
}else{
printf("Usage: %s <domain> <host>\n", argv[0]);
}
return 0;
}
FCGX_Stream *in;
FCGX_Stream *out;
FCGX_Stream *err;
FCGX_ParamArray envp;
char *method = NULL;
while(FCGX_Accept(&in, &out, &err, &envp) >= 0)
{
method = FCGX_GetParam("REQUEST_METHOD", envp);
if(strcmp(method, "POST") == 0){
//request_post(in, out, &envp);
}else if(strcmp(method, "GET") == 0){
request_get(in, out, &envp);
}
}
FCGX_Finish();
//test();
return 0;
}
int answer_to_connection (void *cls, struct MHD_Connection *connection,const char *url, const char *method,const char *version, const char *upload_data,
size_t *upload_data_size, void **con_cls)
{
struct MHD_Response *response;
puts(page);
if (strcmp(method,"GET") == 0)
{
printf("%s New %s request for %s using version %s",__func__, method, url, version);
request_get(cls, connection, url, method, version, upload_data, upload_data_size, con_cls);
return 1;
}
else if (strcmp(method,"PUT") == 0)
{
printf("%s New %s request for %s using version %s",__func__, method, url, version);
request_put( cls, connection, url, method, version, upload_data, upload_data_size,con_cls);
return 1;
}
else if (strcmp(method,"DELETE") == 0)
{
printf("%s New %s request for %s using version %s",__func__, method, url, version);
request_delete( cls, connection, url, method, version, upload_data, upload_data_size,con_cls);
}
else if (strcmp(method,"HEAD") == 0)
{
printf("%s New %s request for %s using version %s",__func__, method, url, version);
request_head( cls, connection, url, method, version, upload_data, upload_data_size,con_cls);
return 1;
}
else if (strcmp(method,"POST") == 0)
{
printf("%s New %s request for %s using version %s",__func__, method, url, version);
request_post(cls, connection, url, method, version, upload_data, upload_data_size, con_cls);
return 1;
}
else
printf("%s ERROR %s request for %s using version %s",__func__, method, url, version);
return 0;
}
static void recv(struct mwService *srvc, struct mwChannel *chan,
guint16 type, struct mwOpaque *data) {
/* process into results, trigger callbacks */
struct mwGetBuffer *b;
struct mwServiceStorage *srvc_stor;
struct mwStorageReq *req;
guint32 id;
g_return_if_fail(srvc != NULL);
srvc_stor = (struct mwServiceStorage *) srvc;
g_return_if_fail(chan != NULL);
g_return_if_fail(chan == srvc_stor->channel);
g_return_if_fail(data != NULL);
b = mwGetBuffer_wrap(data);
id = guint32_peek(b);
req = request_find(srvc_stor, id);
if(! req) {
g_warning("couldn't find request 0x%x in storage service", id);
mwGetBuffer_free(b);
return;
}
g_return_if_fail(req->action == type);
request_get(b, req);
if(mwGetBuffer_error(b)) {
mw_mailme_opaque(data, "storage request 0x%x, type: 0x%x", id, type);
} else {
request_trigger(srvc_stor, req);
}
mwGetBuffer_free(b);
request_remove(srvc_stor, req);
}
void request_perform(const RequestParams *params, S3RequestContext *context)
{
Request *request;
S3Status status;
#define return_status(status) \
(*(params->completeCallback))(status, 0, params->callbackData); \
return
// These will hold the computed values
RequestComputedValues computed;
// Validate the bucket name
if (params->bucketContext.bucketName &&
((status = S3_validate_bucket_name
(params->bucketContext.bucketName,
params->bucketContext.uriStyle)) != S3StatusOK)) {
return_status(status);
}
// Compose the amz headers
if ((status = compose_amz_headers(params, &computed)) != S3StatusOK) {
return_status(status);
}
// Compose standard headers
if ((status = compose_standard_headers
(params, &computed)) != S3StatusOK) {
return_status(status);
}
// URL encode the key
if ((status = encode_key(params, &computed)) != S3StatusOK) {
return_status(status);
}
// Compute the canonicalized amz headers
canonicalize_amz_headers(&computed);
// Compute the canonicalized resource
canonicalize_resource(params->bucketContext.bucketName,
params->subResource, computed.urlEncodedKey,
computed.canonicalizedResource);
// Compose Authorization header
if ((status = compose_auth_header(params, &computed)) != S3StatusOK) {
return_status(status);
}
// Get an initialized Request structure now
if ((status = request_get(params, &computed, &request)) != S3StatusOK) {
return_status(status);
}
// If a RequestContext was provided, add the request to the curl multi
if (context) {
CURLMcode code = curl_multi_add_handle(context->curlm, request->curl);
if (code == CURLM_OK) {
if (context->requests) {
request->prev = context->requests->prev;
request->next = context->requests;
context->requests->prev->next = request;
context->requests->prev = request;
}
else {
context->requests = request->next = request->prev = request;
}
}
else {
if (request->status == S3StatusOK) {
request->status = (code == CURLM_OUT_OF_MEMORY) ?
S3StatusOutOfMemory : S3StatusInternalError;
}
request_finish(request);
}
}
// Else, perform the request immediately
else {
CURLcode code = curl_easy_perform(request->curl);
if ((code != CURLE_OK) && (request->status == S3StatusOK)) {
request->status = request_curl_code_to_status(code);
}
// Finish the request, ensuring that all callbacks have been made, and
// also releases the request
request_finish(request);
}
}
/*
int
print_out_key (void *cls, enum MHD_ValueKind kind, const char *key,
const char *value)
{
SimpleLog_Write(SL_DEBUG, __func__, "%s: %s", key, value);
return MHD_YES;
}
*/
int
answer_to_connection (void *cls, struct MHD_Connection *connection,
const char *url, const char *method,
const char *version, const char *upload_data,
size_t *upload_data_size, void **con_cls)
{
/*the info of this thread, so we need there to be defined in function,
not be defined as global variables.
*/
// json_object * Response_page = json_object_new_object();
//json_object * Response_heads = json_object_new_object();
//const char *page = "hello, cloud store!";
struct MHD_Response *response;
//puts(page);
//int ret;
char pathname[128];
char pathname_mnt[128];
get_sonstr(url,pathname);
memset(pathname_mnt,0,sizeof(pathname_mnt));
strcat(strcat(pathname_mnt,"/mnt/supercache/"),pathname);
//printf("pathname %s pathname_mnt %s \n",pathname,pathname_mnt);
if (strcmp(method,"GET") == 0)
{
printf("haha\n");
//SimpleLog_Write(SL_DEBUG, __func__, "New %s request for %s using version %s", method, url, version);
printf("%s New %s request for %s using version %s",__func__, method, url, version);
/******************add by Jin*********************************/
/*time_t arrive_time;
time(&arrive_time);
IO_Type io_type=READ;
queue_in_wait(pathname_mnt,io_type,arrive_time);
int already_queue_out=0;//the mark of read out early
Meta_Data * meta_data=(Meta_Data*)malloc(sizeof(Meta_Data));
if(md_get(pathname_mnt,meta_data)==0)
{
u32 head_next=((*meta_data).ioq.head+1)%IO_Q_LEN;
//if one read comes after one read ,queue out early
if((*meta_data).ioq.io_q_node[head_next].io_type==READ)
{
read_queue_out(pathname_mnt,io_type,arrive_time);
already_queue_out=1;
}
}*/
/*******************************************************/
request_get(cls, connection, url, method, version, upload_data,
upload_data_size, con_cls);
/* if(already_queue_out==0)
{
read_queue_out(pathname_mnt,io_type,arrive_time);
}*/
return 1;
}
else if (strcmp(method,"PUT") == 0)
{
//SimpleLog_Write(SL_DEBUG, __func__, "New %s request for %s using version %s", method, url, version);
printf("%s New %s request for %s using version %s",__func__, method, url, version);
/******************************************************/
/*time_t arrive_time;
time(&arrive_time);
IO_Type io_type=WRITE;
queue_in_wait(pathname_mnt,io_type,arrive_time);*/
/********************************************************/
request_put( cls, connection, url, method, version, upload_data,
upload_data_size,con_cls);
/*********************************************************/
/*u64 offset=0;char *data="never mind!";size_t size1=11;
write_queue_out(pathname_mnt,io_type,arrive_time,offset,data,size1);//should change it*/
/*********************************************************/
return 1;
}
else if (strcmp(method,"DELETE") == 0)
{
//SimpleLog_Write(SL_DEBUG, __func__, "New %s request for %s using version %s", method, url, version);
printf("%s New %s request for %s using version %s",__func__, method, url, version);
/************************************************/
/* time_t arrive_time;
time(&arrive_time);
IO_Type io_type=REMOVE;
queue_in_wait(pathname_mnt,io_type,arrive_time);*/
/************************************************/
request_delete( cls, connection, url, method, version, upload_data,
upload_data_size,con_cls);
//remove_queue_out(pathname_mnt,io_type);
}
else if (strcmp(method,"HEAD") == 0)
{
//SimpleLog_Write(SL_DEBUG, __func__, "New %s request for %s using version %s", method, url, version);
printf("%s New %s request for %s using version %s",__func__, method, url, version);
request_head( cls, connection, url, method, version, upload_data,
upload_data_size,con_cls);
return 1;
}
else if (strcmp(method,"POST") == 0)
{
//printf("()()()()\n");
//SimpleLog_Write(SL_DEBUG, __func__, "New %s request for %s using version %s", method, url, version);
//printf("%s New %s request for %s using version %s\n",__func__, method, url, version);
//printf("up_load_size:%u %s\n",upload_data_size,upload_data);
/******************************************************/
/*time_t arrive_time;
time(&arrive_time);
IO_Type io_type=WRITE;
queue_in_wait(pathname_mnt,io_type,arrive_time);*/
/********************************************************/
request_post(cls, connection, url, method, version, upload_data,
upload_data_size, con_cls);
/*********************************************************/
/*u64 offset=0;char *data="never mind!";size_t size1=11;
write_queue_out(pathname_mnt,io_type,arrive_time,offset,data,size1);//should change it*/
/*********************************************************/
return 1;
}
else
printf("%s ERROR %s request for %s using version %s",__func__, method, url, version);
return 0;
}
