int main(int argc, char *argv[]) { int ret; int sock; sock = socket(PF_INET, SOCK_STREAM, 0); if (sock < 0) { do_err("socket"); } struct sockaddr_in servaddr; memset(&servaddr, 0, sizeof (servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(SERVER_PORT); servaddr.sin_addr.s_addr = inet_addr(SERVER_IP); ret = connect(sock, (struct sockaddr *) &servaddr, sizeof(servaddr)); if (ret < 0) { do_err("connect"); } struct sockaddr_in localaddr; socklen_t addrlen = sizeof(localaddr); ret = getsockname(sock, (struct sockaddr *) &localaddr, &addrlen); if (ret < 0) { do_err("getsockname"); } printf("client: %s:%hu\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port)); struct sockaddr_in peeraddr; addrlen = sizeof(peeraddr); ret = getpeername(sock, (struct sockaddr *) &peeraddr, &addrlen); if (ret < 0) { do_err("getsockname"); } printf("server: %s:%hu\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port)); char recvbuff[1024] = {0}; // memset(&sendbuff, 0, sizeof(sendbuff)); while (1) { if (scanf("%d%d", &sendbuff.fst, &sendbuff.scd) == 2) { sendbuff.checkvalue = checksum((unsigned char *)&sendbuff, sizeof(sendbuff)); write(sock, &sendbuff, sizeof(sendbuff)); ret = read(sock, recvbuff, sizeof(recvbuff)); if (ret == -1) { do_err("read"); } else if (ret == 0) { printf("server closed.\n"); break; } printf("result: %s\n", recvbuff); memset(recvbuff, 0, sizeof(recvbuff)); memset(&sendbuff, 0, sizeof(sendbuff)); } else { printf("wrong input\n"); break; } } close(sock); return 0; }
int main(int argc, char *argv[]) { void *buf; _xcc_status cc; unsigned short count_read; unsigned short count_written; unsigned short count_xferred; int ferr; short filenum; int loop = 16; char my_name[BUFSIZ]; bool nowait = false; int nid; char *p; int pid; char recv_buffer[BUFSIZ]; char send_buffer[BUFSIZ]; SB_Tag_Type tag; short tfilenum; int tm_seq; int timeout = -1; MS_Mon_Transid_Type transid; TAD zargs[] = { { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-nowait", TA_Bool, TA_NOMAX, &nowait }, { "-print", TA_Bool, TA_NOMAX, &print }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "", TA_End, TA_NOMAX, NULL } }; TRANSID_SET_NULL(curr_transid); TRANSID_SET_NULL(exp_trans); ferr = file_init(&argc, &argv); TEST_CHK_FEOK(ferr); msfs_util_init_fs(&argc, &argv, file_debug_hook); arg_proc_args(zargs, false, argc, argv); util_test_start(client); ferr = file_mon_process_startup(!client); // system messages TEST_CHK_FEOK(ferr); util_gethostname(my_name, sizeof(my_name)); ferr = msg_mon_trans_register_tmlib(tmlib); TEST_CHK_FEOK(ferr); ferr = msg_mon_get_process_info(NULL, &nid, &pid); TEST_CHK_FEOK(ferr); if (client) { ferr = XFILE_OPEN_((char *) "$srv", 4, &filenum, 0, 0, nowait ? (short) 1 : (short) 0, 0, 0, 0, 0, NULL); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { ferr = msg_mon_get_tm_seq(&tm_seq); TEST_CHK_FEOK(ferr); if (!do_trans(inx)) tm_seq = 0; sprintf(send_buffer, "hello, greetings from %s, inx=%d, trans=%d", my_name, inx, tm_seq); if (print) printf("client enlist, transid=%d\n", tm_seq); TRANSID_SET_SEQ(transid, tm_seq); trans_set_curr(transid); if (tm_seq) { ferr = msg_mon_trans_enlist(nid, pid, transid); TEST_CHK_FEOK(ferr); } if (do_trans(inx)) fun_set(TMLIB_FUN_GET_TX, TMLIB_FUN_REINSTATE_TX); else fun_set(TMLIB_FUN_GET_TX, -1); trans_set(transid); cc = XWRITEREADX(filenum, send_buffer, (short) (strlen(send_buffer) + 1), BUFSIZ, &count_read, 0); if (nowait) { TEST_CHK_CCEQ(cc); tfilenum = filenum; cc = XAWAITIOX(&tfilenum, &buf, &count_xferred, &tag, timeout, NULL); } if (do_err(inx)) { if (do_err_inx(inx) == ERR_S2) { TEST_CHK_CCEQ(cc); } else if (do_trans(inx)) { TEST_CHK_CCNE(cc); } else if (do_err_inx(inx) == ERR_C1) { TEST_CHK_CCNE(cc); } else { TEST_CHK_CCEQ(cc); } // fun_check(-1); } else { TEST_CHK_CCEQ(cc); fun_check(-1); } if (print) printf("client end, transid=%d\n", tm_seq); if (tm_seq) { ferr = msg_mon_trans_end(nid, pid, transid); TEST_CHK_FEOK(ferr); TRANSID_SET_NULL(transid); trans_set_curr(transid); // no more trans } printf("%s\n", send_buffer); } ferr = XFILE_CLOSE_(filenum, 0); TEST_CHK_FEOK(ferr); } else { ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenum, 0, 0, nowait ? (short) 1 : (short) 0, 1, 1, // no sys msg 0, 0, NULL); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { if (do_err(inx)) { if (do_err_inx(inx) == ERR_C1) continue; // we don't get these } if (do_trans(inx)) fun_set(TMLIB_FUN_REG_TX, -1); else fun_set(-1, -1); cc = XREADUPDATEX(filenum, recv_buffer, BUFSIZ, &count_read, 0); TEST_CHK_CCEQ(cc); if (nowait) { tfilenum = filenum; cc = XAWAITIOX(&tfilenum, &buf, &count_xferred, &tag, timeout, NULL); TEST_CHK_CCEQ(cc); } p = &recv_buffer[strlen(recv_buffer)]; while ((p > recv_buffer) && (*p != '=')) p--; if (*p == '=') { p++; sscanf(p, "%d", &tm_seq); TRANSID_SET_SEQ(transid, tm_seq); } else TRANSID_SET_NULL(transid); if (!do_trans(inx)) { MS_Mon_Transid_Type ltransid; TRANSID_SET_NULL(ltransid); trans_set_curr(ltransid); } trans_set(transid); trans_check(curr_transid); fun_check(-1); if (do_trans(inx)) fun_set(TMLIB_FUN_CLEAR_TX, -1); else fun_set(-1, -1); strcat(recv_buffer, "- reply from "); strcat(recv_buffer, my_name); count_read = (short) (strlen(recv_buffer) + 1); cc = XREPLYX(recv_buffer, count_read, &count_written, 0, XZFIL_ERR_OK); TEST_CHK_CCEQ(cc); fun_check(-1); } ferr = XFILE_CLOSE_(filenum, 0); TEST_CHK_FEOK(ferr); } ferr = file_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
std::string Get::traitementmap() { bool ok; ok = false; int lines; int caractere = 0; std::string fichier; std::string mess; std::string extension; std::string extendfolder; std::map<std::string,std::string>::iterator it; if(serveur::getMap("Protocole", _map).compare("HTTP/1.1") == 0) { if(serveur::getMap("host", _map).compare("Erreur") == 0) { _Reponse.clear(); do_err("400",_Reponse,_map); return _Reponse; } } _Reponse = serveur::getMap("Protocole", _map); fichier = "." + serveur::getMap("get", _map); std::cout << fichier <<"-" << std::endl; extension = serveur::getMap("get", _map).substr(serveur::getMap("get", _map).find_last_of('.') + 1,serveur::getMap("get", _map).length()); std::cout << extension <<"-" << std::endl; if(extension == "html") extendfolder = "text/html"; else if(extension == "jpeg") extendfolder = "image/jpeg"; else if(extension == "mpeg") extendfolder= "audio/mpeg"; else if(extension == "txt") extendfolder = "text/plain"; else std::cout << "erreur extension fichier" << std::endl; std::ifstream file(fichier.c_str()); std::string ligne; // variable contenant chaque ligne lu if (file) { ok = true; _Reponse += "200 Ok\n" ; } else { _Reponse += " 404 Not Found\n"; string temp; temp = "<!DOCTYPE HTML PUBLIC ";//IETF//DTD HTML 2.0//EN"> temp += "<html><head>\n"; temp += "<title>404 Not Found</title>\n"; temp += "</head><body>\n"; temp += "<h1>Not Found</h1>\n"; temp += "<p>The requested URL /ltest.ffd was not found on this server.</p>\n"; temp += "</body></html>\n"; int a; a = (int)temp.length(); char taile[20]; sprintf(taile, "%d\n",a); std::string toto = taile; _Reponse += "Content-Length: "; _Reponse += toto; _Reponse += "\n"; _Reponse += temp; _Reponse += "\n"; return _Reponse; } if (ok == true) { while ( std::getline(file, ligne ) ) { mess += ligne; } } std::string temp; int a; a = (int)mess.length(); char taile[20]; sprintf(taile, "%d\n",a); std::string toto = taile; _Reponse += "Date : "; _Reponse += serveur::date().c_str(); _Reponse += "\n"; _Reponse += "Server : Zia/0.1\nContent-type: "; _Reponse += extendfolder.c_str(); _Reponse += "\n"; _Reponse += "Content-Length: " + toto; _Reponse += "\n"; _Reponse += mess; _Reponse += "\n"; //std::cout << _Reponse <<"-----------------------------------------" << std::endl; return _Reponse; }
int tmlib(MS_Mon_Tmlib_Fun_Type fun, MS_Mon_Transid_Type transid, MS_Mon_Transid_Type *transid_out) { const char *funp; MS_Mon_Transid_Type ltransid; int ret; if (exp_fun < 0) { printf("client=%d, cb not expected\n", client); assert(false); // callback not expected } else fun_check(fun); switch (fun) { case TMLIB_FUN_REG_TX: funp = "REG"; trans_set_curr(transid); break; case TMLIB_FUN_CLEAR_TX: funp = "CLEAR"; TRANSID_SET_NULL(ltransid); trans_set_curr(ltransid); break; case TMLIB_FUN_REINSTATE_TX: funp = "REINSTATE"; if (client) trans_check(transid); trans_set_curr(transid); break; case TMLIB_FUN_GET_TX: funp = "GET"; break; default: funp = "<unknown>"; assert(false); TRANSID_SET_NULL(ltransid); trans_set_curr(ltransid); break; } if (print) { char transidbuf[100]; char curr_transidbuf[100]; const char *clientp = client ? "client" : "server"; util_format_transid(transidbuf, transid); util_format_transid(curr_transidbuf, curr_transid); printf("%s tmlib callback, fun=%s(%d), transid=%s, curr-transid=%s\n", clientp, funp, fun, transidbuf, curr_transidbuf); } fun_set(exp_fun_next, -1); if (fun == TMLIB_FUN_GET_TX) *transid_out = curr_transid; ret = 0; if (do_err(inx)) { switch (fun) { case TMLIB_FUN_REG_TX: if (do_err_inx(inx) == ERR_S1) { fun_set(TMLIB_FUN_REG_TX, -1); ret = inx; inx++; // side-effect } break; case TMLIB_FUN_CLEAR_TX: if (do_err_inx(inx) == ERR_S2) ret = inx; break; case TMLIB_FUN_REINSTATE_TX: if (do_err_inx(inx) == ERR_C2) ret = inx; break; case TMLIB_FUN_GET_TX: if (do_err_inx(inx) == ERR_C1) ret = inx; break; default: assert(false); break; } } if (print) { const char *clientp = client ? "client" : "server"; printf("%s tmlib callback, fun=%s(%d), ret=%d\n", clientp, funp, fun, ret); } return ret; }
int CThreadBeatHeart::run() { #define do_err() if(pconnector != NULL) \ { \ delete pconnector; \ pconnector = NULL; \ } \ if(preport_stream != NULL) \ { \ delete preport_stream; \ preport_stream = NULL; \ } \ if(preport_resp_body != NULL) \ { \ delete [] preport_resp_body; \ preport_resp_body = NULL; \ } int ret; int i, vnode_count; int vnode_id; int64_t body_len; byte vnode_status; time_t nlast_beat_time; char proxy_ip[KL_COMMON_IP_ADDR_LEN]; CConnector *pconnector = NULL; CTimedStream *preport_stream = NULL; pkg_header report_resp_header; pkg_message *pstorage_sync_msg; byte *preport_resp_body = NULL; vnode_resp_info *pvnode_resp_unit; storage_sync_event *pstorage_sync_event; try { pconnector = new CConnector(m_proxy_addr); } catch(std::bad_alloc) { pconnector = NULL; KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create beat-hearting connector", \ __LINE__); return ENOMEM; } catch(int errcode) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "call CConnector constructor failed, err: %s", \ __LINE__, strerror(errcode)); return errcode; } try { preport_stream = new CTimedStream(); } catch(std::bad_alloc) { preport_stream = NULL; KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create beat-hearting sock stream", \ __LINE__); do_err(); return ENOMEM; } catch(int errcode) { preport_stream = NULL; KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "call CTimedStream constructor failed, err: %s", \ __LINE__, strerror(errcode)); return errcode; } if(pconnector->stream_connect(preport_stream) != 0) { m_proxy_addr.getipaddress(proxy_ip, sizeof(proxy_ip)); KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "connect to proxy node(ip: %s, port: %d) failed, err: %s", \ __LINE__, proxy_ip, m_proxy_addr.getport(), strerror(errno)); do_err(); return errno; } if(join_and_report(preport_stream) != 0) { m_proxy_addr.getipaddress(proxy_ip, sizeof(proxy_ip)); KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "send join request to proxy node(ip: %s, port: %d) failed", \ __LINE__, proxy_ip, m_proxy_addr.getport()); do_err(); return -1; } nlast_beat_time = time(NULL); while(m_bstop_flag != true) { //KL_SYS_INFOLOG("beat-hearting thread report loop"); if(time(NULL) - nlast_beat_time < KL_STORAGE_BEAT_INTERVAL) { sleep(1); continue; } //KL_SYS_INFOLOG("beat-hearting thread true report loop"); nlast_beat_time = time(NULL); if((ret = report_vnode_info(preport_stream)) != 0) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "report storage vnode information failed, err: %s", \ __LINE__, strerror(ret)); do_err(); return ret; } //KL_SYS_INFOLOG("beat-hearting thread report success"); //to receive the reponse from proxy node if((ret = preport_stream->stream_recv(&report_resp_header, \ sizeof(report_resp_header), g_ntimeout)) != 0) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "report thread recv report response header failed, err: %s", \ __LINE__, strerror(ret)); do_err(); return ret; } //KL_SYS_INFOLOG("recv header ret: %d, pkg_header len: %d", ret, sizeof(pkg_header)); //check the response status if(report_resp_header.status != 0) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "storage node beat-hearting msg's response is occured with error", \ __LINE__); do_err(); return -1; } //check whether response message is legal body_len = CSERIALIZER::buff2int64(report_resp_header.pkg_len); if(body_len == 0) { //proxy resp msg, have no body to merge continue; } else if(report_resp_header.cmd == KL_PROXY_CMD_SLAVER_RESP) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "report thread recv slaver resp msg is illegal", \ __LINE__); return -1; } if((body_len % sizeof(vnode_resp_info) != 0)) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "report thread recv master resp body len(body_len: %d) is illegal", \ __LINE__, body_len); do_err(); return -1; } try { preport_resp_body = new byte[body_len]; } catch(std::bad_alloc) { preport_resp_body = NULL; KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create report response body buffer(pkg_len: %ld)", \ __LINE__, body_len); do_err(); return ENOMEM; } //to receive response body if((ret = preport_stream->stream_recv(preport_resp_body, body_len, g_ntimeout)) != 0) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "report thread recv report response body failed, err: %s", \ __LINE__, strerror(ret)); do_err(); return ret; } //KL_SYS_INFOLOG("recv body ret: %d, body len: %d", ret, body_len); //parse response body vnode_count = body_len / sizeof(vnode_resp_info); for(i = 0; i < vnode_count; i++) { pvnode_resp_unit = (vnode_resp_info *)(preport_resp_body + \ i * sizeof(vnode_resp_info)); vnode_id = CSERIALIZER::buff2int32(pvnode_resp_unit->vnode_id); vnode_status = pvnode_resp_unit->vnode_status; //KL_SYS_INFOLOG("vnode_id: %d, vnode_status: %d", vnode_id, vnode_status); if((ret = merge_vnode_status(vnode_id, vnode_status)) != 0) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "report thread merge vnode status failed, vnode_id: %d, vnode_status: %d, " \ "errcode: %d", \ __LINE__, vnode_id, vnode_status, ret); do_err(); return ret; } //KL_SYS_INFOLOG("beat-hearting merge vnode status success"); if(vnode_status != KL_REPLICA_STATUS_COPY_SRC && \ vnode_status != KL_REPLICA_STATUS_MOVE_SRC) continue; try { pstorage_sync_event = (storage_sync_event *)(new byte[sizeof(storage_sync_event)]); } catch(std::bad_alloc) { pstorage_sync_event = NULL; KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create storage sync event obj", \ __LINE__); do_err(); return ENOMEM; } try { pstorage_sync_msg = new pkg_message(); } catch(std::bad_alloc) { pstorage_sync_msg = NULL; KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "no more memory to create storage sync msg obj", \ __LINE__); delete pstorage_sync_event; do_err(); return ENOMEM; } pstorage_sync_event->vnode_id = vnode_id; pstorage_sync_event->sync_dest_port = \ CSERIALIZER::buff2int32(pvnode_resp_unit->sync_dest_port); memcpy(pstorage_sync_event->sync_dest_ip, pvnode_resp_unit->sync_dest_ip, \ KL_COMMON_IP_ADDR_LEN); pstorage_sync_msg->pkg_len = sizeof(storage_sync_event); pstorage_sync_msg->pkg_ptr = (byte*)pstorage_sync_event; m_psync_msg_queue->push_msg(pstorage_sync_msg); //KL_SYS_INFOLOG("push sync event(vnode_id: %d) success", vnode_id); } delete [] preport_resp_body; preport_resp_body = NULL; g_sync_down_rwlock.wrlock(); if(m_nthread_index == 0 && !g_sync_down_queue.empty()) { ret = report_sync_down_info(preport_stream); } g_sync_down_rwlock.unlock(); if(ret != 0) { KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \ "report storage node sync down info failed, err: %s", \ __LINE__, strerror(ret)); do_err(); return ret; } } do_err(); return 0; }