/******************************************************************************* * SEND ALARM MESSAGE TO COND *******************************************************************************/ void Send_AlmMsg( char loctype, char invtype, short invno, char almstatus, char oldalm) { st_almsts almsts; int dRet; pst_MsgQ pstSndMsg; pst_MsgQSub pstSndSub; U8 *pNODE; if( (dRet = dGetNode(&pNODE, &pstSndMsg)) < 0 ){ log_print(LOGN_CRI,LH"FAILED IN dGetNode(CHSMD)",LT); return; } memset( &almsts, 0x00, DEF_ALMSTS_SIZE ); almsts.ucSysType = SYSTYPE_TAF; almsts.ucSysNo = (unsigned char)gdSysNo; /* NTAF */ almsts.ucLocType = loctype; almsts.ucInvType = invtype; almsts.ucInvNo = invno; almsts.ucAlmLevel = almstatus; almsts.ucOldAlmLevel = oldalm; if( loctype == LOCTYPE_LOAD ){ CalcLoad( invtype, invno, &almsts.llLoadVal ); } else almsts.llLoadVal = 0; time(&almsts.tWhen); set_time(almsts.ucLocType, almsts.ucInvType, almsts.ucInvNo, almsts.tWhen); #ifdef DEBUG log_print(LOGN_INFO,"LOCTYPE[%x], INVTYPE[%x], INVNO[%d] ALMSTATUS[%x]", loctype, invtype, invno, almstatus ); #endif /* Head 결정 */ pstSndSub = (pst_MsgQSub)(unsigned long*)&pstSndMsg->llMType; pstSndSub->usType = DEF_SYS; pstSndSub->usSvcID = SID_STATUS; pstSndSub->usMsgID = MID_ALARM; util_makenid( SEQ_PROC_CHSMD, &pstSndMsg->llNID ); pstSndMsg->ucNTAMID = 0; pstSndMsg->ucNTAFID = almsts.ucSysNo; pstSndMsg->ucProID = SEQ_PROC_CHSMD; pstSndMsg->llIndex = dNIDIndex; dNIDIndex++; pstSndMsg->dMsgQID = 0; /* * NTAFT_HEADER_LEN < Socket Header Size 만큼 + */ pstSndMsg->usBodyLen = DEF_ALMSTS_SIZE; pstSndMsg->usRetCode = 0; //memset( pstSndMsg->szBody, 0x00, MNG_PKT_HEAD_SIZE ); memcpy( &pstSndMsg->szBody[0], &almsts, pstSndMsg->usBodyLen ); /*************************************************************************** * ALMD로 메시지 전송 ***************************************************************************/ if( (dRet = dMsgsnd(SEQ_PROC_ALMD, pNODE)) < 0 ){ log_print(LOGN_CRI, LH"FAILED IN dMsgsnd(ALMD)"EH, LT, ET); return; } log_print(LOGN_DEBUG, LH"SUCCESS IN dMsgsnd(ALMD) MESSAGE PROCESSID=%d, BLEN=%d", LT, SEQ_PROC_ALMD, pstSndMsg->usBodyLen); /*************************************************************************** * COND로 전송하던 내용을 전송하는 부분 추가 ***************************************************************************/ pstSndSub->usMsgID = MID_CONSOL; pstSndMsg->dMsgQID = 0; if( (dRet = dMsgsnd(SEQ_PROC_CI_SVC, pNODE)) < 0 ){ log_print(LOGN_CRI, LH"FAILED IN dMsgsnd(CI_SVC)"EH, LT, ET); return; } log_print(LOGN_DEBUG, LH"SUCCESS IN dMsgsnd(CI_SVC) MESSAGE PROCESSID=%d, BLEN=%d, SID=%d, MID=%d", LT, SEQ_PROC_CI_SVC, pstSndMsg->usBodyLen, pstSndSub->usSvcID, pstSndSub->usMsgID); /* UPDATE fidb.mem */ write_FIDB(); return; }
int PlayerGetVFilterFormat(play_para_t*am_p) { signed short video_index = am_p->vstream_info.video_index; char value[1024]; int filter_fmt = 0; unsigned int codec_id; if (video_index != -1) { AVStream *pStream; AVCodecContext *pCodecCtx; pStream = am_p->pFormatCtx->streams[video_index]; pCodecCtx = pStream->codec; if (am_p->stream_type == STREAM_ES && pCodecCtx->codec_tag != 0) { codec_id=pCodecCtx->codec_tag; } else { codec_id=pCodecCtx->codec_id; } if ((pCodecCtx->codec_id == CODEC_ID_H264MVC) && (!am_p->vdec_profile.hmvc_para.exist)) { filter_fmt |= FILTER_VFMT_HMVC; } if ((pCodecCtx->codec_id == CODEC_ID_H264) && (!am_p->vdec_profile.h264_para.exist)) { filter_fmt |= FILTER_VFMT_H264; } } if (GetSystemSettingString("media.amplayer.disable-vcodecs", value, NULL) > 0) { log_print("[%s:%d]disable_vdec=%s\n", __FUNCTION__, __LINE__, value); if (strstr(value,"MPEG12") != NULL || strstr(value,"mpeg12") != NULL) { filter_fmt |= FILTER_VFMT_MPEG12; } if (strstr(value,"MPEG4") != NULL || strstr(value,"mpeg4") != NULL) { filter_fmt |= FILTER_VFMT_MPEG4; } if (strstr(value,"H264") != NULL || strstr(value,"h264") != NULL) { filter_fmt |= FILTER_VFMT_H264; } if (strstr(value,"MJPEG") != NULL || strstr(value,"mjpeg") != NULL) { filter_fmt |= FILTER_VFMT_MJPEG; } if (strstr(value,"REAL") != NULL || strstr(value,"real") != NULL) { filter_fmt |= FILTER_VFMT_REAL; } if (strstr(value,"JPEG") != NULL || strstr(value,"jpeg") != NULL) { filter_fmt |= FILTER_VFMT_JPEG; } if (strstr(value,"VC1") != NULL || strstr(value,"vc1") != NULL) { filter_fmt |= FILTER_VFMT_VC1; } if (strstr(value,"AVS") != NULL || strstr(value,"avs") != NULL) { filter_fmt |= FILTER_VFMT_AVS; } if (strstr(value,"SW") != NULL || strstr(value,"sw") != NULL) { filter_fmt |= FILTER_VFMT_SW; } if (strstr(value,"HMVC") != NULL || strstr(value,"hmvc") != NULL){ filter_fmt |= FILTER_VFMT_HMVC; } /*filter by codec id*/ if (strstr(value,"DIVX3") != NULL || strstr(value,"divx3") != NULL){ if (codec_id == CODEC_TAG_DIV3) filter_fmt |= FILTER_VFMT_MPEG4; } if (strstr(value,"DIVX4") != NULL || strstr(value,"divx4") != NULL){ if (codec_id == CODEC_TAG_DIV4) filter_fmt |= FILTER_VFMT_MPEG4; } if (strstr(value,"DIVX5") != NULL || strstr(value,"divx5") != NULL){ if (codec_id == CODEC_TAG_DIV5) filter_fmt |= FILTER_VFMT_MPEG4; } } log_print("[%s:%d]filter_vfmt=%x\n", __FUNCTION__, __LINE__, filter_fmt); return filter_fmt; }
/** * @brief Main function for oaextendmpi and oaextendsingle * @param argc * @param argv[] * @return */ int main (int argc, char *argv[]) { #ifdef OAEXTEND_SINGLECORE const int n_processors = 1; const int this_rank = 0; #else MPI::Init (argc, argv); const int n_processors = MPI::COMM_WORLD.Get_size (); const int this_rank = MPI::COMM_WORLD.Get_rank (); #endif // printf("MPI: this_rank %d\n", this_rank); /*----------SET STARTING ARRAY(S)-----------*/ if (this_rank != MASTER) { #ifdef OAEXTEND_MULTICORE slave_print (QUIET, "M: running core %d/%d\n", this_rank, n_processors); #endif algorithm_t algorithm = MODE_INVALID; AnyOption *opt = parseOptions (argc, argv, algorithm); OAextend oaextend; oaextend.setAlgorithm (algorithm); #ifdef OAEXTEND_MULTICORE log_print (NORMAL, "slave: receiving algorithm int\n"); algorithm = (algorithm_t)receive_int_slave (); oaextend.setAlgorithm (algorithm); // printf("slave %d: receive algorithm %d\n", this_rank, algorithm); #endif extend_slave_code (this_rank, oaextend); delete opt; } else { double Tstart = get_time_ms (); int nr_extensions; arraylist_t solutions, extensions; algorithm_t algorithm = MODE_INVALID; AnyOption *opt = parseOptions (argc, argv, algorithm); print_copyright (); int loglevel = opt->getIntValue ('l', NORMAL); setloglevel (loglevel); int dosort = opt->getIntValue ('s', 1); int userowsymm = opt->getIntValue ("rowsymmetry", 1); int maxk = opt->getIntValue ("maxk", 100000); int initcolprev = opt->getIntValue ("initcolprev", 1); const bool streaming = opt->getFlag ("streaming"); bool restart = false; if (opt->getValue ("restart") != NULL || opt->getValue ('r') != NULL) { restart = true; } const char *oaconfigfile = opt->getStringValue ('c', "oaconfig.txt"); const char *resultprefix = opt->getStringValue ('o', "result"); arrayfile::arrayfilemode_t mode = arrayfile_t::parseModeString (opt->getStringValue ('f', "T")); OAextend oaextend; oaextend.setAlgorithm (algorithm); if (streaming) { logstream (SYSTEM) << "operating in streaming mode, sorting of arrays will not work " << std::endl; oaextend.extendarraymode = OAextend::STOREARRAY; } // J5_45 int xx = opt->getFlag ('x'); if (xx) { oaextend.j5structure = J5_45; } if (userowsymm == 0) { oaextend.use_row_symmetry = userowsymm; printf ("use row symmetry -> %d\n", oaextend.use_row_symmetry); } if (opt->getFlag ('g')) { std::cout << "only generating arrays (no LMC check)" << endl; oaextend.checkarrays = 0; } if (opt->getFlag ("help") || (opt->getValue ("coptions") != NULL)) { if (opt->getFlag ("help")) { opt->printUsage (); } if (opt->getValue ("coptions") != NULL) { print_options (cout); } } else { logstream (QUIET) << "#time start: " << currenttime () << std::endl; arraydata_t *ad; ad = readConfigFile (oaconfigfile); ad->lmc_overflow_check (); if (ad == 0) { return 1; } log_print (NORMAL, "Using design file: %s (runs %d, strength %d)\n", oaconfigfile, ad->N, ad->strength); if (oaextend.getAlgorithm () == MODE_AUTOSELECT) { oaextend.setAlgorithmAuto (ad); } #ifdef OAEXTEND_SINGLECORE if (initcolprev == 0) { log_print (NORMAL, "setting oaextend.init_column_previous to %d\n", INITCOLUMN_ZERO); oaextend.init_column_previous = INITCOLUMN_ZERO; } #endif #ifdef OAEXTEND_MULTICORE int alg = oaextend.getAlgorithm (); for (int i = 0; i < n_processors; i++) { if (i == MASTER) { continue; } log_print (NORMAL, "MASTER: sending algorithm %d to slave %d\n", alg, i); send_int (alg, i); } #endif colindex_t col_start; log_print (SYSTEM, "using algorithm %d (%s)\n", oaextend.getAlgorithm (), oaextend.getAlgorithmName ().c_str ()); if (log_print (NORMAL, "")) { cout << oaextend.__repr__ (); } if (restart) { // start from result file int initres = init_restart (opt->getValue ('r'), col_start, solutions); if (initres == 1) { // check if restarting went OK logstream (SYSTEM) << "Problem with restart from " << opt->getValue ('r') << "" << endl; #ifdef OAEXTEND_MPI MPI_Abort (MPI_COMM_WORLD, 1); #endif exit (1); } if (dosort) { double Ttmp = get_time_ms (); sort (solutions.begin (), solutions.end ()); // solutions.sort(); log_print (QUIET, " sorting of initial solutions: %.3f [s]\n", get_time_ms () - Ttmp); } // check that oaconfig agrees with loaded arrays if (solutions.size () > 0) { if (ad->N != solutions[0].n_rows) { printf ("Problem: oaconfig does not agree with loaded arrays!\n"); // free_sols(solutions); ?? solutions.clear (); } } } else { // starting with root if (check_divisibility (ad) == false) { log_print (SYSTEM, "ERROR: Failed divisibility test!\n"); #ifdef OAEXTEND_MPI MPI_Abort (MPI_COMM_WORLD, 1); #endif exit (1); } create_root (ad, solutions); col_start = ad->strength; } /*-----------MAIN EXTENSION LOOP-------------*/ log_print (SYSTEM, "M: running with %d procs\n", n_processors); maxk = std::min (maxk, ad->ncols); time_t seconds; for (colindex_t current_col = col_start; current_col < maxk; current_col++) { fflush (stdout); arraydata_t *adcol = new arraydata_t (ad, current_col + 1); if (streaming) { string fname = resultprefix; fname += "-streaming"; fname += "-" + oafilestring (ad); logstream (NORMAL) << "oaextend: streaming mode: create file " << fname << std::endl; int nb = arrayfile_t::arrayNbits (*ad); oaextend.storefile.createfile (fname, adcol->N, ad->ncols, -1, ABINARY, nb); } log_print (SYSTEM, "Starting with column %d (%d, total time: %.2f [s])\n", current_col + 1, (int)solutions.size (), get_time_ms () - Tstart); nr_extensions = 0; arraylist_t::const_iterator cur_extension; int csol = 0; for (cur_extension = solutions.begin (); cur_extension != solutions.end (); cur_extension++) { print_progress (csol, solutions, extensions, Tstart, current_col); logstream (NORMAL) << cur_extension[0]; if (n_processors == 1) { nr_extensions += extend_array (*cur_extension, adcol, current_col, extensions, oaextend); } else { #ifdef OAEXTEND_MPI throw_runtime_exception("mpi version of oextend is no longer supported"); double Ttmp = get_time_ms (); int slave = collect_solutions_single (extensions, adcol); log_print (DEBUG, " time: %.2f, collect time %.2f\n", (get_time_ms () - Tstart), (get_time_ms () - Ttmp)); /* OPTIMIZE: send multiple arrays to slave 1 once step */ extend_array_mpi (cur_extension->array, 1, adcol, current_col, slave); #endif } #ifdef OAEXTEND_MPI if ((csol + 1) % nsolsync == 0) { collect_solutions_all (extensions, adcol); } #endif // OPTIMIZE: periodically write part of the solutions to disk csol++; /* increase current solution */ } #ifdef OAEXTEND_MPI collect_solutions_all (extensions, adcol); #endif if (checkloglevel (NORMAL)) { csol = 0; for (cur_extension = extensions.begin (); cur_extension != extensions.end (); cur_extension++) { log_print (DEBUG, "%i: -----\n", ++csol); logstream (DEBUG) << cur_extension[0]; } } if (dosort) { log_print (DEBUG, "Sorting solutions, necessary for multi-processor code\n"); double Ttmp = get_time_ms (); sort (extensions.begin (), extensions.end ()); log_print (DEBUG, " sorting time: %.3f [s]\n", get_time_ms () - Ttmp); } save_arrays (extensions, adcol, resultprefix, mode); solutions.swap (extensions); // swap old and newly found solutions extensions.clear (); // clear old to free up space for new extensions log_print (SYSTEM, "Done with column %i, total of %i solutions (time %.2f s))\n", current_col + 1, (int)solutions.size (), get_time_ms () - Tstart); delete adcol; #ifdef OAANALYZE_DISCR logstream (NORMAL) << "Discriminant: " << endl; print_discriminant (ad->N, current_col + 1); #endif } /*------------------------*/ time (&seconds); struct tm *tminfo; tminfo = localtime (&seconds); log_print (SYSTEM, "TIME: %.2f s, %s", get_time_ms () - Tstart, asctime (tminfo)); logstream (QUIET) << "#time end: " << currenttime () << std::endl; logstream (QUIET) << "#time total: " << printfstring ("%.1f", get_time_ms () - Tstart) << " [s]" << std::endl; solutions.clear (); delete ad; #ifdef OAEXTEND_MPI stop_slaves (); #endif } delete opt; } /* end of master code */ #ifdef OAEXTEND_MPI MPI_Finalize (); #endif return 0; }
static gint smtp_session_recv_msg(Session *session, const gchar *msg) { SMTPSession *smtp_session = SMTP_SESSION(session); gboolean cont = FALSE; gint ret = 0; if (strlen(msg) < 4) { log_warning(LOG_PROTOCOL, _("bad SMTP response\n")); return -1; } switch (smtp_session->state) { case SMTP_EHLO: case SMTP_STARTTLS: case SMTP_AUTH: case SMTP_AUTH_PLAIN: case SMTP_AUTH_LOGIN_USER: case SMTP_AUTH_LOGIN_PASS: case SMTP_AUTH_CRAM_MD5: log_print(LOG_PROTOCOL, "ESMTP< %s\n", msg); break; default: log_print(LOG_PROTOCOL, "SMTP< %s\n", msg); break; } /* ignore all multiline responses except for EHLO */ if (msg[3] == '-' && smtp_session->state != SMTP_EHLO) return session_recv_msg(session); if (msg[0] == '5' && msg[1] == '0' && (msg[2] == '4' || msg[2] == '3' || msg[2] == '1')) { log_warning(LOG_PROTOCOL, _("error occurred on SMTP session\n")); smtp_session->state = SMTP_ERROR; smtp_session->error_val = SM_ERROR; g_free(smtp_session->error_msg); smtp_session->error_msg = g_strdup(msg); return -1; } if (!strncmp(msg, "535", 3)) { log_warning(LOG_PROTOCOL, _("error occurred on authentication\n")); smtp_session->state = SMTP_ERROR; smtp_session->error_val = SM_AUTHFAIL; g_free(smtp_session->error_msg); smtp_session->error_msg = g_strdup(msg); return -1; } if (msg[0] != '1' && msg[0] != '2' && msg[0] != '3') { log_warning(LOG_PROTOCOL, _("error occurred on SMTP session\n")); smtp_session->state = SMTP_ERROR; smtp_session->error_val = SM_ERROR; g_free(smtp_session->error_msg); smtp_session->error_msg = g_strdup(msg); return -1; } if (msg[3] == '-') cont = TRUE; else if (msg[3] != ' ' && msg[3] != '\0') { log_warning(LOG_PROTOCOL, _("bad SMTP response\n")); smtp_session->state = SMTP_ERROR; smtp_session->error_val = SM_UNRECOVERABLE; return -1; } switch (smtp_session->state) { case SMTP_READY: if (strstr(msg, "ESMTP")) smtp_session->is_esmtp = TRUE; #ifdef USE_GNUTLS if (smtp_session->user || session->ssl_type != SSL_NONE || smtp_session->is_esmtp) #else if (smtp_session->user || smtp_session->is_esmtp) #endif ret = smtp_ehlo(smtp_session); else ret = smtp_helo(smtp_session); break; case SMTP_HELO: ret = smtp_from(smtp_session); break; case SMTP_EHLO: ret = smtp_ehlo_recv(smtp_session, msg); if (cont == TRUE) break; if (smtp_session->max_message_size > 0 && smtp_session->max_message_size < smtp_session->send_data_len) { log_warning(LOG_PROTOCOL, _("Message is too big " "(Maximum size is %s)\n"), to_human_readable( (goffset)(smtp_session->max_message_size))); smtp_session->state = SMTP_ERROR; smtp_session->error_val = SM_ERROR; return -1; } #ifdef USE_GNUTLS if (session->ssl_type == SSL_STARTTLS && smtp_session->tls_init_done == FALSE) { ret = smtp_starttls(smtp_session); break; } #endif if (smtp_session->user) { if (smtp_auth(smtp_session) != SM_OK) { #ifdef USE_GNUTLS if (session->ssl_type == SSL_NONE && smtp_session->tls_init_done == FALSE && (smtp_session->avail_auth_type & SMTPAUTH_TLS_AVAILABLE)) ret = smtp_starttls(smtp_session); else #endif ret = smtp_from(smtp_session); } } else ret = smtp_from(smtp_session); break; case SMTP_STARTTLS: #ifdef USE_GNUTLS if (session_start_tls(session) < 0) { log_warning(LOG_PROTOCOL, _("couldn't start TLS session\n")); smtp_session->state = SMTP_ERROR; smtp_session->error_val = SM_ERROR; return -1; } smtp_session->tls_init_done = TRUE; ret = smtp_ehlo(smtp_session); #endif break; case SMTP_AUTH: ret = smtp_auth_recv(smtp_session, msg); break; case SMTP_AUTH_LOGIN_USER: ret = smtp_auth_login_user_recv(smtp_session, msg); break; case SMTP_AUTH_PLAIN: case SMTP_AUTH_LOGIN_PASS: case SMTP_AUTH_CRAM_MD5: ret = smtp_from(smtp_session); break; case SMTP_FROM: if (smtp_session->cur_to) ret = smtp_rcpt(smtp_session); break; case SMTP_RCPT: if (smtp_session->cur_to) ret = smtp_rcpt(smtp_session); else ret = smtp_data(smtp_session); break; case SMTP_DATA: ret = smtp_send_data(smtp_session); break; case SMTP_EOM: smtp_make_ready(smtp_session); break; case SMTP_QUIT: session_disconnect(session); break; case SMTP_ERROR: default: log_warning(LOG_PROTOCOL, _("error occurred on SMTP session\n")); smtp_session->error_val = SM_ERROR; return -1; } if (cont && ret == SM_OK) return session_recv_msg(session); if (ret != SM_OK) smtp_session->error_val = SM_ERROR; return ret == SM_OK ? 0 : -1; }
int print_stat(struct stat *stbuf, const char *title) { if (debug) { log_print(LOG_DEBUG, "stat: %s", title); log_print(LOG_DEBUG, " .st_mode=%04o", stbuf->st_mode); log_print(LOG_DEBUG, " .st_nlink=%ld", stbuf->st_nlink); log_print(LOG_DEBUG, " .st_uid=%d", stbuf->st_uid); log_print(LOG_DEBUG, " .st_gid=%d", stbuf->st_gid); log_print(LOG_DEBUG, " .st_size=%ld", stbuf->st_size); log_print(LOG_DEBUG, " .st_blksize=%ld", stbuf->st_blksize); log_print(LOG_DEBUG, " .st_blocks=%ld", stbuf->st_blocks); log_print(LOG_DEBUG, " .st_atime=%ld", stbuf->st_atime); log_print(LOG_DEBUG, " .st_mtime=%ld", stbuf->st_mtime); log_print(LOG_DEBUG, " .st_ctime=%ld", stbuf->st_ctime); } return 0; }
bool_t check_string_realloc(char *type, uint32_t check) { size_t len; stringer_t *s, *swap; if (!(s = st_alloc(check, 1)) || !(swap = st_realloc(s, st_length_get(constant)))) { if (s) { st_free(s); } return false; } // Since mapped allocations are page aligned, we reallocate to a larger than needed size to ensure an actual reallocation occurs. else if (check & MAPPED_T && !(swap = st_realloc(s, st_length_get(constant) + (getpagesize() * 128)))) { if (s) { st_free(s); } return false; } // Jointed strings allow reallocation without changing the address of s, of if the string is jointed and s changes, error out. else if (check & JOINTED && swap != s) { st_free(swap); st_free(s); return false; } // Contiguous strings will require the address of s to change, so if it doesn't error out. Except for the mapped type, since the jointed flag doesn't apply to it. else if (!(check & JOINTED) && !(check & MAPPED_T) && swap == s) { st_free(s); return false; } // For contiguous types, free the original string and replace it with the value of swap. else if (swap != s) { st_free(s); s = swap; } len = snprintf(st_char_get(s), st_length_int(constant) + 1, "%.*s", st_length_int(constant), st_char_get(constant)); if (check & MAPPED_T || check & MANAGED_T) { st_length_set(s, len); } else if (memcmp(st_char_get(s), st_char_get(constant), st_length_get(constant))) { return false; } // Enlarge a buffer by a factor of 128 and make sure the data it contained wasn't changed. For managed or mapped strings, multiply the available space. if (check & (MANAGED_T | MAPPED_T) && !(swap = st_realloc(s, st_avail_get(s) * 128))) { st_free(s); return false; } // For other string types we multiply the space used by the string since the original allocation size isn't tracked. else if (!(check & (MANAGED_T | MAPPED_T)) && !(swap = st_realloc(s, st_length_get(s) * 128))) { st_free(s); return false; } // Since mapped allocations are page aligned, we reallocate to a larger than needed size to ensure an actual reallocation occurs. else if (check & MAPPED_T && !(swap = st_realloc(s, st_length_get(constant) + (getpagesize() * 128)))) { if (s) { st_free(s); } return false; } // Jointed strings allow reallocation without changing the address of s, of if the string is jointed and s changes, error out. else if (check & JOINTED && swap != s) { st_free(swap); st_free(s); return false; } // Contiguous strings will require the address of s to change, so if it doesn't error out. Except for the mapped type, since the jointed flag doesn't apply to it. else if ((check & JOINTED) ^ JOINTED && !(check & MAPPED_T) && swap == s) { st_free(s); return false; } // For contiguous types, free the original string and replace it with the value of swap. else if (swap != s) { st_free(s); s = swap; } else if (memcmp(st_char_get(s), st_char_get(constant), st_length_get(constant))) { return false; } // Now we shrink the buffer back to the bare minimum and check the data one final time. if (!(swap = st_realloc(s, st_length_get(constant)))) { if (s) { st_free(s); } return false; } else if (swap != s) { st_free(s); s = swap; } log_print("%28.28s = %.*s", type, st_length_int(s), st_char_get(s)); st_free(s); return true; }
int sys_start(int argc, char *argv[]) { int status; const char* f; lua_State *L; if (argc<2) { printf("%s: <filename.lua>\n", argv[0]); return 1; } s_init(); log_print("sound> initialized\n"); L = lua_open(); /*luaopen_base(L);*/ luaL_openlibs(L); luaopen_sys(L); luaopen_log(L); luaopen_mat4(L); luaopen_quat(L); luaopen_vec3(L); luaopen_event(L); luaopen_image(L); luaopen_render(L); luaopen_shader(L); luaopen_sound(L); luaopen_net(L); luaopen_util(L); luaopen_font(L); luaopen_md2(L); //luaopen_blender(L); lua_getglobal(L, "package"); if (LUA_TTABLE != lua_type(L, 1)) { log_print("lua> 'package' is not a table\n"); return 1; } lua_getfield(L, 1, "path"); if (LUA_TSTRING != lua_type(L, 2)) { log_print("lua> 'package.path' is not a string\n"); lua_pop(L, 1); return 1; } lua_pop(L, 1); #if defined(__IPHONE__) f = full_path(); #else f = "."; #endif /* package.path = f .. "/?.lua" */ lua_pushlstring(L, f, strlen(f)); lua_pushliteral(L, "/?.lua"); lua_concat(L, 2); lua_setfield(L, 1, "path"); lua_bootstrap(L, f); #if defined(__IPHONE__) f = full_path_to_file(argv[1]); #else f = argv[1]; #endif log_print("lua> initialized\n"); printf("lua> loading %s\n", f); if (luaL_loadfile(L,f)==0) { /* function runme = file_content */ lua_setglobal(L, "runme"); lua_getglobal(L, "runme"); status = lua_pcall(L,0,LUA_MULTRET,0); assert(0 == report(L, status)); if (lua_gettop(L) > 0) { status = lua_toboolean(L, -1); if (!status) { printf("lua> %s returned false\n", f); sys_quit(); } } log_print("lua> loaded\n"); } else { printf("lua> unable to load %s\n",f); report(L, status); sys_quit(); } lua_state = L; /* TODO: Double check this stuff some day when bored. */ return status > 0 ? false : true; }
static int _pv_resize_single(struct cmd_context *cmd, struct volume_group *vg, struct physical_volume *pv, const uint64_t new_size) { struct pv_list *pvl; uint64_t size = 0; uint32_t new_pe_count = 0; int r = 0; struct dm_list mdas; const char *pv_name = pv_dev_name(pv); const char *vg_name = pv_vg_name(pv); struct lvmcache_info *info; int mda_count = 0; struct volume_group *old_vg = vg; dm_list_init(&mdas); if (is_orphan_vg(vg_name)) { if (!lock_vol(cmd, vg_name, LCK_VG_WRITE)) { log_error("Can't get lock for orphans"); return 0; } if (!(pv = pv_read(cmd, pv_name, &mdas, NULL, 1, 0))) { unlock_vg(cmd, vg_name); log_error("Unable to read PV \"%s\"", pv_name); return 0; } mda_count = dm_list_size(&mdas); } else { vg = vg_read_for_update(cmd, vg_name, NULL, 0); if (vg_read_error(vg)) { vg_release(vg); log_error("Unable to read volume group \"%s\".", vg_name); return 0; } if (!(pvl = find_pv_in_vg(vg, pv_name))) { log_error("Unable to find \"%s\" in volume group \"%s\"", pv_name, vg->name); goto out; } pv = pvl->pv; if (!(info = info_from_pvid(pv->dev->pvid, 0))) { log_error("Can't get info for PV %s in volume group %s", pv_name, vg->name); goto out; } mda_count = dm_list_size(&info->mdas); if (!archive(vg)) goto out; } /* FIXME Create function to test compatibility properly */ if (mda_count > 1) { log_error("%s: too many metadata areas for pvresize", pv_name); goto out; } if (!(pv->fmt->features & FMT_RESIZE_PV)) { log_error("Physical volume %s format does not support resizing.", pv_name); goto out; } /* Get new size */ if (!dev_get_size(pv_dev(pv), &size)) { log_error("%s: Couldn't get size.", pv_name); goto out; } if (new_size) { if (new_size > size) log_warn("WARNING: %s: Overriding real size. " "You could lose data.", pv_name); log_verbose("%s: Pretending size is %" PRIu64 " not %" PRIu64 " sectors.", pv_name, new_size, pv_size(pv)); size = new_size; } if (size < PV_MIN_SIZE) { log_error("%s: Size must exceed minimum of %ld sectors.", pv_name, PV_MIN_SIZE); goto out; } if (size < pv_pe_start(pv)) { log_error("%s: Size must exceed physical extent start of " "%" PRIu64 " sectors.", pv_name, pv_pe_start(pv)); goto out; } pv->size = size; if (vg) { pv->size -= pv_pe_start(pv); new_pe_count = pv_size(pv) / vg->extent_size; if (!new_pe_count) { log_error("%s: Size must leave space for at " "least one physical extent of " "%" PRIu32 " sectors.", pv_name, pv_pe_size(pv)); goto out; } if (!pv_resize(pv, vg, new_pe_count)) goto_out; } log_verbose("Resizing volume \"%s\" to %" PRIu64 " sectors.", pv_name, pv_size(pv)); log_verbose("Updating physical volume \"%s\"", pv_name); if (!is_orphan_vg(vg_name)) { if (!vg_write(vg) || !vg_commit(vg)) { log_error("Failed to store physical volume \"%s\" in " "volume group \"%s\"", pv_name, vg->name); goto out; } backup(vg); } else if (!(pv_write(cmd, pv, NULL, INT64_C(-1)))) { log_error("Failed to store physical volume \"%s\"", pv_name); goto out; } log_print("Physical volume \"%s\" changed", pv_name); r = 1; out: unlock_vg(cmd, vg_name); if (!old_vg) vg_release(vg); return r; }
/** main function. * * man Function * * @param argc : 파라미터 개수 * @param *argv[] : 파라미터 * * @return S32 * @see o_svcmon_main.c o_svcmon_init.c o_svcmon_func.c * * @exception . * @note . **/ S32 main(S32 argc, S8 *argv[]) { S32 isChanged = 0, isHashChg = 0; S32 dRet; time_t curtime, oldtime, stattime, nowstat; time_t stattime2, nowstat2; st_WatchMsg *pWATCH; st_MonList *pMonList = NULL, *pOldMonList = NULL; st_MonList_1Min *pMonList1Min = NULL; st_SvcMonMsg *pSvcMonMsg; st_MsgQ stMsgQ; st_MsgQSub *pstMsgQSub = (st_MsgQSub *)&stMsgQ.llMType; /* log_print 초기화 */ log_init(S_SSHM_LOG_LEVEL, getpid(), SEQ_PROC_O_SVCMON, LOG_PATH"/O_SVCMON", "O_SVCMON"); /* O_SVCMON 초기화 */ if((dRet = dInitOSVCMON(&pDefHash, &pAMonHash, &pSMonHash, &pThresHash, &pNasIPHash)) < 0) { log_print(LOGN_CRI, "[%s][%s.%d] dInitOSVCMON dRet[%d]", __FILE__, __FUNCTION__, __LINE__, dRet); exit(0); } if( (dRet = set_version(S_SSHM_VERSION, SEQ_PROC_O_SVCMON, vERSION)) != 0) log_print( LOGN_CRI, "set_version error(ret=%d,idx=%d,ver=%s)", dRet,SEQ_PROC_ALMD,vERSION); pMonHash = pAMonHash; pNextMonHash = pSMonHash; pBaseMonList1Min = &stABaseMonList1Min; pNextBaseMonList1Min = &stSBaseMonList1Min; log_print(LOGN_CRI, "START O_SVCMON"); curtime = time(NULL); oldtime = time(NULL); stattime = curtime / DEF_MON_PERIOD * DEF_MON_PERIOD; dMakeThresHash(pThresHash, gWatchFilter); dMakeBaseMonList(pMonHash, pNasIPHash, gWatchFilter, &stBaseMonList, pBaseMonList1Min); pMonList = pGetNextMonList(gMonTotal, &stBaseMonList); pOldMonList = pMonList; pMonList1Min = pGetNextMon1MinList(gMonTotal1Min, pBaseMonList1Min); //PRINTLOG(LOG_DEBUG, 0, pMonList, pMonList1Min); /* MAIN LOOP */ while(giStopFlag) { dRet = dIsReceivedMessage(&stMsgQ); if(dRet < 0) { log_print(LOGN_CRI, "F=%s:%s.%d dIsReceivedMessage dRet=%d", __FILE__, __FUNCTION__, __LINE__, dRet); usleep(0); } else if(dRet == 100 || dRet == 0) { usleep(0); } else { log_print(LOGN_INFO, "RCV MSG TYPE=%u SVCID=%u MSGID=%u. TOTSIZE[%ld]" , pstMsgQSub->usType, pstMsgQSub->usSvcID, pstMsgQSub->usMsgID, sizeof(st_MsgQSub)); switch(pstMsgQSub->usType) { case DEF_SYS: switch(pstMsgQSub->usSvcID) { case SID_STATUS: switch(pstMsgQSub->usMsgID) { case MID_SVC_MONITOR: pWATCH = (st_WatchMsg *)stMsgQ.szBody; dProcMON(pDefHash, pMonHash, pNasIPHash, pWATCH, pMonList, &stBaseMonList, pMonList1Min, pBaseMonList1Min); //PRINTLOG(LOGN_INFO, 1, pMonList, pMonList1Min); break; default: log_print(LOGN_INFO, "UNKNOWN MSGID TYPE=%u SVCID=%u MSGID=%u", pstMsgQSub->usType, pstMsgQSub->usSvcID, pstMsgQSub->usMsgID); break; } break; case SID_FLT: switch(pstMsgQSub->usMsgID) { case MID_FLT_SVC: case MID_FLT_SCTP: case MID_FLT_EQUIP: case MID_FLT_ACCESS: log_print(LOGN_CRI, "RCV FILTER UPDATE"); dMakeBaseMonList(pNextMonHash, pNasIPHash, gWatchFilter, &stBaseMonList, pNextBaseMonList1Min); isChanged = 1; break; case MID_FLT_MON_THRES: log_print(LOGN_CRI, "RCV THRESHOLD UPDATE"); dMakeThresHash(pThresHash, gWatchFilter); break; default: log_print(LOGN_INFO, "UNKNOWN MSGID TYPE=%u SVCID=%u MSGID=%u", pstMsgQSub->usType, pstMsgQSub->usSvcID, pstMsgQSub->usMsgID); break; } break; default: log_print(LOGN_INFO, "UNKNOWN SVCID TYPE=%u SVCID=%u MSGID=%u", pstMsgQSub->usType, pstMsgQSub->usSvcID, pstMsgQSub->usMsgID); break; } break; default: log_print(LOGN_INFO, "UNKNOWN TYPE TYPE=%u SVCID=%u MSGID=%u", pstMsgQSub->usType, pstMsgQSub->usSvcID, pstMsgQSub->usMsgID); break; } } curtime = time(NULL); if(curtime != oldtime) { nowstat = curtime / DEF_MON_PERIOD * DEF_MON_PERIOD; if(stattime != nowstat) { /* check alarm */ dAlarmMON(pThresHash, pMonHash, pMonList, pOldMonList); pSvcMonMsg = (st_SvcMonMsg *)stMsgQ.szBody; pSvcMonMsg->lTime = pMonList->lTime; pSvcMonMsg->uiIdx = gMonTotal->dCurIdx; log_print(LOGN_INFO, "MID_SVC_MONITOR: pSvcMonMsg->lTime[%ld] pSvcMonMsg->uiIdx[%u]", pSvcMonMsg->lTime, pSvcMonMsg->uiIdx); pstMsgQSub->usType = DEF_SYS; pstMsgQSub->usSvcID = SID_STATUS; pstMsgQSub->usMsgID = MID_SVC_MONITOR; stMsgQ.ucProID = SEQ_PROC_O_SVCMON; stMsgQ.usBodyLen = sizeof(st_SvcMonMsg); /* send signal to mond */ if((dRet = dSendMsg(dMONDQID, &stMsgQ)) < 0) { log_print(LOGN_CRI, "F=%s:%s.%d dSendMsg dRet=%d", __FILE__, __FUNCTION__, __LINE__, dRet); } #ifndef _DISABLE_INTERLOCK_DNMS_ /* DNMS interlock disabled by uamyd 20101101 */ /* send signal to m_svcmon */ if((dRet = dSendMsg(dMSVCMONQID, &stMsgQ)) < 0) { log_print(LOGN_CRI, "F=%s:%s.%d dSendMsg dRet=%d", __FILE__, __FUNCTION__, __LINE__, dRet); } #endif /* _DISABLE_INTERLOCK_DNMS_ */ //PRINTLOG(LOG_DEBUG, 1, pMonList, pMonList1Min); PRINT_FUNC_TIME_CHECK(pFUNC); pOldMonList = pMonList; /* get next st_MonList */ pMonList = pGetNextMonList(gMonTotal, &stBaseMonList); if(isChanged) { void *p = pMonHash; pMonHash = pNextMonHash; pNextMonHash = p; p = pBaseMonList1Min; pBaseMonList1Min = pNextBaseMonList1Min; pNextBaseMonList1Min = p; isChanged = 0; isHashChg = 1; } stattime = nowstat; } nowstat2 = curtime / DEF_MON_PERIOD_1MIN * DEF_MON_PERIOD_1MIN; if( stattime2 != nowstat2 ) { if(isHashChg) { dAlarmMON1Min(pThresHash, pNextMonHash, pMonList1Min); isHashChg = 0; } else { dAlarmMON1Min(pThresHash, pMonHash, pMonList1Min); } pSvcMonMsg = (st_SvcMonMsg *)stMsgQ.szBody; pSvcMonMsg->lTime = pMonList1Min->lTime; pSvcMonMsg->uiIdx = gMonTotal1Min->dCurIdx; log_print(LOGN_INFO, "MID_SVC_MONITOR_1MIN: pSvcMonMsg->lTime[%ld] pSvcMonMsg->uiIdx[%u]", pSvcMonMsg->lTime, pSvcMonMsg->uiIdx); pstMsgQSub->usType = DEF_SYS; pstMsgQSub->usSvcID = SID_STATUS; pstMsgQSub->usMsgID = MID_SVC_MONITOR_1MIN; stMsgQ.ucProID = SEQ_PROC_O_SVCMON; stMsgQ.usBodyLen = sizeof(st_SvcMonMsg); /* send signal to mond */ if((dRet = dSendMsg(dALMDQID, &stMsgQ)) < 0) { log_print(LOGN_CRI, "F=%s:%s.%d dSendMsg dRet=%d", __FILE__, __FUNCTION__, __LINE__, dRet); } #ifndef _DISABLE_INTERLOCK_DNMS_ /* DNMS interlock disabled by uamyd 20101101 */ /* send signal to m_svcmon */ if((dRet = dSendMsg(dMSVCMONQID, &stMsgQ)) < 0) { log_print(LOGN_CRI, "F=%s:%s.%d dSendMsg dRet=%d", __FILE__, __FUNCTION__, __LINE__, dRet); } #endif /* _DISABLE_INTERLOCK_DNMS_ */ //PRINTLOG(LOG_DEBUG, 1, pMonList, pMonList1Min); PRINT_FUNC_TIME_CHECK(pFUNC); /* get next st_MonList */ pMonList1Min = pGetNextMon1MinList(gMonTotal1Min, pBaseMonList1Min); #if 0 if(isChanged) { void *p = pMonHash; pMonHash = pNextMonHash; pNextMonHash = p; isChanged = 0; } #endif stattime2 = nowstat2; } oldtime = curtime; } } FinishProgram(); return 0; }
int ffmpeg_parse_file_type(play_para_t *am_p, player_file_type_t *type) { AVFormatContext *pFCtx = am_p->pFormatCtx; AVStream *sttmp=NULL; memset(type, 0, sizeof(*type)); memset(&am_p->media_info, 0, sizeof(media_info_t)); if (pFCtx->iformat != NULL) { unsigned int i; int matroska_flag = 0; int vpx_flag = 0; int flv_flag = 0; type->fmt_string = pFCtx->iformat->name; if (!strcmp(type->fmt_string, "matroska,webm")) { matroska_flag = 1; } if (!strcmp(type->fmt_string, "flv")) { flv_flag = 1; } for (i = 0; i < pFCtx->nb_streams; i++) { AVStream *st = pFCtx->streams[i]; if (st->codec->codec_type == CODEC_TYPE_VIDEO) { // special process for vp8 vp6 vp6f vp6a video if ((st->codec->codec_id == CODEC_ID_VP8) || \ (st->codec->codec_id == CODEC_ID_VP6) || \ (st->codec->codec_id == CODEC_ID_VP6F) || \ (st->codec->codec_id == CODEC_ID_VP6A)) { if (vpx_flag == 0) { sprintf(vpx_string, "%s", (st->codec->codec_id == CODEC_ID_VP8) ? "vp8" : "vp6"); vpx_flag = 1; } } type->video_tracks++; } else if (st->codec->codec_type == CODEC_TYPE_AUDIO) { type->audio_tracks++; sttmp=st; } else if (st->codec->codec_type == CODEC_TYPE_SUBTITLE) { type->subtitle_tracks++; } } //--------special process for m4a format with alac codec---------- if((type->video_tracks==0) && (type->audio_tracks==1) && (sttmp!=NULL)) { if((strstr(type->fmt_string,"m4a")!=NULL) && (sttmp->codec->codec_id==CODEC_ID_ALAC)) { memset(format_string, 0, sizeof(format_string)); //memcpy(format_string,"alac",4); sprintf(format_string, "%s","alac"); log_print("NOTE: change type->fmt_string=%s to alac\n", type->fmt_string); type->fmt_string = format_string; } if((strstr(type->fmt_string,"aac")!=NULL) && (sttmp->codec->codec_id==CODEC_ID_AAC)) { unsigned char* buf=pFCtx->pb->buffer; log_print("pFCtx->data_offset=%lld %c %c %c %c\n",pFCtx->data_offset,buf[0],buf[1], buf[2],buf[3]); if((buf[0]=='A' && buf[1]=='D' && buf[2]=='I' && buf[3]=='F')) { log_print("the stream is pure adif: set adif_ctrl_flag=1\n"); am_p->media_info.stream_info.adif_file_flag=1; } } if((strstr(type->fmt_string,"asf")!=NULL) && pFCtx->drmcontent ) { log_print("drm wma detected\n"); memset(format_string, 0, sizeof(format_string)); sprintf(format_string, "%s","asf-drm"); type->fmt_string = format_string; } } //----------------------------------------------------- // special process for webm/vpx, flv/vp6 if (matroska_flag || flv_flag || vpx_flag) { int length = 0; memset(format_string, 0, sizeof(format_string)); if (matroska_flag == 1) { length = sprintf(format_string, "%s", (vpx_flag == 1) ? "webm" : "matroska"); } else { length = sprintf(format_string, "%s", type->fmt_string); } if (vpx_flag == 1) { sprintf(&format_string[length], ",%s", vpx_string); memset(vpx_string, 0, sizeof(vpx_string)); } type->fmt_string = format_string; } } return 0; }
int main(int argc, char *argv[]) { S32 i; S32 dRet; OFFSET offset; time_t oldTime, nowTime; Capture_Header_Msg *pCAPHEAD; INFO_ETH *pINFOETH; CALL_KEY *pCALLKey; U8 *pNode; UINT dSndQID; SESSKEY_LIST *pstSESSKEYList; char szLOGPATH[128]; int dLen, PROCNO; int LastLogTime; char vERSION[7] = "R3.0.0"; /* process name */ memcpy(&gszMyProc[0], argv[0], strlen(argv[0])); dLen = strlen(gszMyProc); PROCNO = atoi(&gszMyProc[dLen-1]); guiSeqProcID = SEQ_PROC_A_TCP0 + PROCNO; /* log_print 초기화 */ sprintf(szLOGPATH, LOG_PATH"/%s", gszMyProc); log_init(S_SSHM_LOG_LEVEL, getpid(), guiSeqProcID, szLOGPATH, gszMyProc); /* A_TCP 초기화 */ if((dRet = dInitTcp(&pMEMSINFO, &pTCPHASH, &pTIMER)) < 0) { log_print(LOGN_CRI, "[%s][%s.%d] dInitTcp dRet[%d]", __FILE__, __FUNCTION__, __LINE__, dRet); exit(0); } if( (dRet = shm_init(S_SSHM_UTIL, sizeof(DEBUG_INFO), (void**)&pDEBUGINFO)) < 0 ){ log_print(LOGN_CRI, "FAILED IN shm_init(DEBUG_INFO=%d)", S_SSHM_UTIL); exit(0); } if((dRet = set_version(S_SSHM_VERSION, guiSeqProcID, vERSION)) < 0 ) { log_print(LOGN_CRI, "SET_VERSION ERROR(RET=%d,IDX=%d,VER=%s)", dRet, guiSeqProcID, vERSION); } log_print(LOGN_CRI, "START %s[%d] TCP_SESS_CNT[%d]", gszMyProc, PROCNO, TCP_SESS_CNT); /* MAIN LOOP */ while(giStopFlag) { START_FUNC_TIME_CHECK(pFUNC, 0); timerN_invoke(pTIMER); END_FUNC_TIME_CHECK(pFUNC, 0); for(i=0; i < 300; i++) { if((offset = gifo_read(pMEMSINFO, gpCIFO, guiSeqProcID)) > 0) { pCAPHEAD = (Capture_Header_Msg *)nifo_get_value(pMEMSINFO, CAP_HEADER_NUM, offset); pINFOETH = (INFO_ETH *)nifo_get_value(pMEMSINFO, INFO_ETH_NUM, offset); pCALLKey = (CALL_KEY *)nifo_get_value(pMEMSINFO, CLEAR_CALL_NUM, offset); pNode = nifo_ptr(pMEMSINFO, offset); if(pCALLKey) { log_print(LOGN_DEBUG, "#### RECEIVE CALL CLEAR MSG IP: %d.%d.%d.%d LASTLOGTIME: %u ", HIPADDR(pCALLKey->uiSrcIP), pCALLKey->uiReserved); LastLogTime = pCALLKey->uiReserved; pCALLKey->uiReserved = 0; if( (pSESSKEYNODE = hasho_find(pSESSKEYINFO, (U8 *)pCALLKey)) != NULL ) { log_print(LOGN_INFO, "#### FIND TCP SESSION LIST IP: %d.%d.%d.%d ", HIPADDR(pCALLKey->uiSrcIP)); pstSESSKEYList = (SESSKEY_LIST *)nifo_ptr(pSESSKEYINFO, pSESSKEYNODE->offset_Data); dRet = dDelSessKeyList(pstSESSKEYList, pTCPHASH, pMEMSINFO, LastLogTime, pTIMER); if(dRet == 0) { hasho_del(pSESSKEYINFO, (U8 *)pCALLKey); } } else { log_print(LOGN_INFO, "#### NOT EXIST CALL IP: %d.%d.%d.%d ", HIPADDR(pCALLKey->uiSrcIP)); } nifo_node_delete(pMEMSINFO, pNode); } else if((pCAPHEAD == NULL) || (pINFOETH == NULL)) { nifo_node_delete(pMEMSINFO, pNode); } else { /* ETC Traffic To A_SIPM */ ////////////////////////////////////////////////////////////////////////////////////////////////// if(pINFOETH->usAppCode == SEQ_PROC_A_VT) {//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// log_print(LOGN_DEBUG, "BYPASS ETC TRAFFIC TO A_SIPT");//////////////////////////////////////// dSend_TCP_Data(pMEMSINFO, SEQ_PROC_A_SIPT, pNode);//////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// } else if(pINFOETH->stIP.ucProtocol == DEF_PROTOCOL_TCP) { if(dProcTcpSess(pMEMSINFO, pTCPHASH, pTIMER, pCAPHEAD, pINFOETH, pNode) < 0) { nifo_node_delete(pMEMSINFO, pNode); } } else { if(pCAPHEAD->bRtxType == DEF_FROM_CLIENT) dSndQID = dGetProcID(pINFOETH->usAppCode, pINFOETH->stIP.dwSrcIP); else dSndQID = dGetProcID(pINFOETH->usAppCode, pINFOETH->stIP.dwDestIP); dSend_TCP_Data(pMEMSINFO, dSndQID, pNode); } } } else { usleep(0); break; } } #if 0 nowTime = time(NULL); if(nowTime >= oldTime + 60) { int hashoCnt = hasho_get_occupied_node_count(pTCPHASH); log_print(LOGN_CRI, "SESS CUR=%lld SESS=%lld RNODE=%lld:%.3fMbps SND=%lld HTTP=%lld ONLI=%lld DIFSEQ=%lld UPD=%lld C7=%lld AFT=%lld HASH=%u:%.2f%%", curSessCnt, sessCnt, rcvNodeCnt, (double)((rcvSize * 8) / (((nowTime - oldTime) == 0) ? 1 : (nowTime - oldTime))) / (1024*1024), allSndCnt, httpSndCnt, onlineSndCnt, diffSeqCnt, updateCnt, case7Cnt, afterCnt, hashoCnt, (float)((float)hashoCnt / ((curSessCnt == 0) ? 1 : curSessCnt)) * 100.0); rcvNodeCnt = 0; rcvSize = 0; httpSndCnt = 0; onlineSndCnt = 0; allSndCnt = 0; diffSeqCnt = 0; sessCnt = 0; updateCnt = 0; case7Cnt = 0; afterCnt = 0; oldTime = nowTime; PRINT_FUNC_TIME_CHECK(pFUNC); } #endif nowTime = time(NULL); if(nowTime >= oldTime + 60) { memcpy(&pDEBUGINFO->ATCPINFO[PROCNO].ATCPSUBINFO, pATCPSUBINFO, sizeof(ATCP_SUBINFO)); pDEBUGINFO->ATCPINFO[PROCNO].curtime = nowTime; pATCPSUBINFO->rcvNodeCnt = 0; pATCPSUBINFO->rcvSize = 0; pATCPSUBINFO->httpSndCnt = 0; pATCPSUBINFO->delCnt = 0; pATCPSUBINFO->allSndCnt = 0; pATCPSUBINFO->diffSeqCnt = 0; pATCPSUBINFO->sessCnt = 0; pATCPSUBINFO->updateCnt = 0; oldTime = nowTime; PRINT_FUNC_TIME_CHECK(pFUNC); } } /* while-loop end (main) */ FinishProgram(); exit(0); }
/** * ci_log로 부터 받은 메시지를 처리한다. * * @param dLen * @param szBuf * @param pstHeader * @param dSubNo * * @return */ int dHandle_RecvMsg(int dLen, char *szBuf, pst_NTAFTHeader pstHeader, int dSubNo) { int dRet, dProcID, type, size; U8 *pNODE, *pDATA; LOG_COMMON *pLOG; #ifdef _RPPI_MULTI_ int dIMSI; /**< IMSI의 뒤에 4자리가 들어갈 변수 */ #endif if(pstHeader->llMagicNumber != MAGIC_NUMBER) { log_print(LOGN_CRI, "dSendToProc : MAGIC NUMBER ERROR, Will be Reset %llu!=%llu", pstHeader->llMagicNumber, MAGIC_NUMBER); return -1; } /* end of if */ switch(pstHeader->ucSvcID) { case SID_LOG: if(dSubNo != pstHeader->ucNTAFID && dSubNo != 0) { log_print(LOGN_WARN, "MSGRCV SVCID=%d MSGID=%d:%s SYSNO=%d:MEM=%d", pstHeader->ucSvcID, pstHeader->ucMsgID, PRINT_DEF_NUM_table_log(pstHeader->ucMsgID), pstHeader->ucNTAFID, dSubNo); } else { log_print(LOGN_INFO, "MSGRCV SVCID=%d MSGID=%d:%s SYSNO=%d:MEM=%d", pstHeader->ucSvcID, pstHeader->ucMsgID, (pstHeader->ucMsgID == START_CALL_NUM || pstHeader->ucMsgID == STOP_CALL_NUM || pstHeader->ucMsgID == START_SERVICE_DEF_NUM) ? PRINT_TAG_DEF_ALL_CALL_INPUT(pstHeader->ucMsgID) : PRINT_DEF_NUM_table_log(pstHeader->ucMsgID), pstHeader->ucNTAFID, dSubNo); } dProcID = SEQ_PROC_A_RPPI; switch(pstHeader->ucMsgID) { case START_CALL_NUM: type = START_CALL_NUM; size = LOG_SIGNAL_SIZE; break; case START_SERVICE_DEF_NUM: type = START_SERVICE_DEF_NUM; size = LOG_COMMON_SIZE; break; case STOP_CALL_NUM: type = STOP_CALL_NUM; size = LOG_SIGNAL_SIZE; break; case LOG_DIALUP_SESS_DEF_NUM: type = LOG_DIALUP_SESS_DEF_NUM; size = LOG_DIALUP_SESS_SIZE; break; case LOG_SIGNAL_DEF_NUM: type = LOG_SIGNAL_DEF_NUM; size = LOG_SIGNAL_SIZE; break; case LOG_TCP_SESS_DEF_NUM: type = LOG_TCP_SESS_DEF_NUM; size = LOG_TCP_SESS_SIZE; break; case LOG_HTTP_TRANS_DEF_NUM: type = LOG_HTTP_TRANS_DEF_NUM; size = LOG_HTTP_TRANS_SIZE; break; case LOG_RTSP_TRANS_DEF_NUM: type = LOG_HTTP_TRANS_DEF_NUM; size = LOG_HTTP_TRANS_SIZE; break; case LOG_PAGE_TRANS_DEF_NUM: type = LOG_PAGE_TRANS_DEF_NUM; size = LOG_PAGE_TRANS_SIZE; break; case LOG_ONLINE_TRANS_DEF_NUM: type = LOG_ONLINE_TRANS_DEF_NUM; size = LOG_ONLINE_TRANS_SIZE; break; case LOG_JNC_TRANS_DEF_NUM: type = LOG_JNC_TRANS_DEF_NUM; size = LOG_JNC_TRANS_SIZE; break; case LOG_IV_DEF_NUM: type = LOG_IV_DEF_NUM; size = LOG_IV_SIZE; break; case LOG_VOD_SESS_DEF_NUM: type = LOG_VOD_SESS_DEF_NUM; size = LOG_VOD_SESS_SIZE; break; case LOG_SIP_TRANS_DEF_NUM: type = LOG_SIP_TRANS_DEF_NUM; size = LOG_SIP_TRANS_SIZE; break; case LOG_MSRP_TRANS_DEF_NUM: type = LOG_MSRP_TRANS_DEF_NUM; size = LOG_MSRP_TRANS_SIZE; break; case LOG_VT_SESS_DEF_NUM: type = LOG_VT_SESS_DEF_NUM; size = LOG_VT_SESS_SIZE; break; case LOG_IM_SESS_DEF_NUM: type = LOG_IM_SESS_DEF_NUM; size = LOG_IM_SESS_SIZE; break; case LOG_FTP_DEF_NUM: type = LOG_FTP_DEF_NUM; size = LOG_FTP_SIZE; break; case st_TraceMsgHdr_DEF_NUM: dProcID = SEQ_PROC_M_TRACE; type = st_TraceMsgHdr_DEF_NUM; size = pstHeader->usBodyLen; break; case LOG_DNS_DEF_NUM: type = LOG_DNS_DEF_NUM; size = LOG_DNS_SIZE; break; case LOG_INET_DEF_NUM: type = LOG_INET_DEF_NUM; size = LOG_INET_SIZE; break; case LOG_ITCP_SESS_DEF_NUM: type = LOG_ITCP_SESS_DEF_NUM; size = LOG_ITCP_SESS_SIZE; break; case LOG_IHTTP_TRANS_DEF_NUM: type = LOG_IHTTP_TRANS_DEF_NUM; size = LOG_IHTTP_TRANS_SIZE; break; case START_PI_DATA_RECALL_NUM: type = START_PI_DATA_RECALL_NUM; size = LOG_SIGNAL_SIZE; break; case START_RP_DATA_RECALL_NUM: type = START_RP_DATA_RECALL_NUM; size = LOG_SIGNAL_SIZE; break; case START_PI_SIG_RECALL_NUM: type = START_PI_SIG_RECALL_NUM; size = LOG_SIGNAL_SIZE; break; case START_RP_SIG_RECALL_NUM: type = START_RP_SIG_RECALL_NUM; size = LOG_SIGNAL_SIZE; break; case STOP_PI_RECALL_NUM: type = STOP_PI_RECALL_NUM; size = LOG_SIGNAL_SIZE; break; case STOP_RP_RECALL_NUM: type = STOP_RP_RECALL_NUM; size = LOG_SIGNAL_SIZE; break; default : log_print(LOGN_CRI, "dSendToProc ERROR : INVALID MSG ID [MID]:[%d] ", pstHeader->ucMsgID); return 0; } if(pstHeader->usBodyLen != size) { log_print(LOGN_CRI, "F=%s:%s.%d DIFF SIZE TYPE=%d:%s RCV=%d ORG=%d", __FILE__, __FUNCTION__, __LINE__, type, PRINT_DEF_NUM_table_log(type), pstHeader->usBodyLen, size); return 0; } if((pNODE = nifo_node_alloc(pMEMSINFO)) == NULL) { log_print(LOGN_CRI, "F=%s:%s.%d nifo_node_alloc NULL TYPE=%d:%s", __FILE__, __FUNCTION__, __LINE__, type, PRINT_DEF_NUM_table_log(type)); return 0; } if((pDATA = nifo_tlv_alloc(pMEMSINFO, pNODE, type, size, DEF_MEMSET_OFF)) == NULL) { log_print(LOGN_CRI, "F=%s:%s.%d nifo_tlv_alloc NULL TYPE=%d:%s", __FILE__, __FUNCTION__, __LINE__, type, PRINT_DEF_NUM_table_log(type)); nifo_node_delete(pMEMSINFO, pNODE); return 0; } memcpy(pDATA, szBuf+NTAFT_HEADER_LEN, size); if(dProcID == SEQ_PROC_A_RPPI) { /** * A_ROAM으로 분기하는 부분 * A_RPPI 멀티시 default 에서 qid를 변경하는 것으로 간단히 처리하겠다. */ pLOG = (LOG_COMMON *)pDATA; switch(pLOG->ucBranchID) { case TYPE_LNS: case TYPE_LAC: case TYPE_CRX: case TYPE_PDIF: log_print(LOGN_INFO, "RCV ROAM DATA BRANCHID=%d", pLOG->ucBranchID); dProcID = SEQ_PROC_A_ROAM; break; default: #ifdef _RPPI_MULTI_ /** * TODO * IMSI의 뒤에 4자리를 숫자로 변경한후 RPPI의 숫자 만큼 mod한다. * mod수를 배열의 index로 참조한 RPPI Queue ID로 node를 write 하겠다. * IMSI 배열의 SIZE는 16이며 define명은 MAX_MIN_SIZE 이다. * 실제 IMSI의 String size는 15이다. * IMSI의 11번째 index부터 atoi로 넘겨서 IMSI를 Number로 변경하겠다. */ dIMSI = atoi((char*)&pLOG->szIMSI[11]); dProcID = SEQ_PROC_A_RPPI0 + (dIMSI % gARPPICnt); log_print(LOGN_INFO, "Send ProcID:%d Index:%d IMSI:%s dIMSI:%d gARPPICnt:%d", dProcID, (dIMSI%gARPPICnt), pLOG->szIMSI, dIMSI, gARPPICnt); if(dProcID == -1) { log_print(LOGN_CRI, LH" *** CAN'T EVENT *** PROCID=%d, IMSI=%d, A_RPPICnt=%d", LT, dProcID, dIMSI, gARPPICnt); nifo_node_delete(pMEMSINFO, pNODE); return 0; } #endif log_print(LOGN_INFO, "RCV DATA BRANCHID=%d", pLOG->ucBranchID); break; } } if((dRet = gifo_write(pMEMSINFO, gpCIFO, SEQ_PROC_SI_LOG, dProcID, nifo_offset(pMEMSINFO, pNODE))) < 0) { log_print(LOGN_CRI, "F=%s:%s.%d gifo_write dRet=%d TYPE=%d:%s", __FILE__, __FUNCTION__, __LINE__, dRet, type, PRINT_DEF_NUM_table_log(type)); nifo_node_delete(pMEMSINFO, pNODE); return 0; } break; default: log_print(LOGN_CRI, "dSendToProc : SVCID=%d MSGID=%d Not Support Msg", pstHeader->ucSvcID, pstHeader->ucMsgID); break; } /* end of switch */ return 0; } /* end of dSendToProc */
/******************************************************************************* FinishProgram *******************************************************************************/ void FinishProgram() { log_print( LOGN_CRI, "PROGRAM IS NORMALLY TERMINATED, Cause = %d", gdFinishFlag); exit(0); }
/******************************************************************************* IGNORE SIGNAL *******************************************************************************/ void IgnoreSignal(int sign) { if (sign != SIGALRM) log_print( LOGN_CRI, "UNWANTED SIGNAL IS RECEIVED, signal = %d", sign); signal(sign, IgnoreSignal); }
bool_t check_string_merge(void) { uint64_t total; bool_t result = true; stringer_t *strings[16]; mm_set(strings, 0, sizeof(strings)); strings[0] = st_alloc(PLACER_T | JOINTED | HEAP, 0); st_placer_set(strings[0], st_data_get(constant), st_length_get(constant)); strings[1] = st_merge(NULLER_T | CONTIGUOUS | HEAP, "s", strings[0]); strings[2] = st_merge(NULLER_T | JOINTED | HEAP, "s", strings[1]); strings[3] = st_merge(BLOCK_T | CONTIGUOUS | HEAP, "s", strings[2]); strings[4] = st_merge(BLOCK_T | JOINTED | HEAP, "s", strings[3]); strings[5] = st_merge(MANAGED_T | CONTIGUOUS | HEAP, "s", strings[4]); strings[6] = st_merge(MANAGED_T | JOINTED | HEAP, "s", strings[5]); strings[7] = st_merge(MAPPED_T | JOINTED | HEAP, "s", strings[6]); strings[8] = st_merge(NULLER_T | CONTIGUOUS | SECURE, "s", strings[7]); strings[9] = st_merge(NULLER_T | JOINTED | SECURE, "s", strings[8]); strings[10] = st_merge(BLOCK_T | CONTIGUOUS | SECURE, "s", strings[9]); strings[11] = st_merge(BLOCK_T | JOINTED | SECURE, "s", strings[10]); strings[12] = st_merge(MANAGED_T | CONTIGUOUS | SECURE, "s", strings[11]); strings[13] = st_merge(MANAGED_T | JOINTED | SECURE, "s", strings[12]); strings[14] = st_merge(MAPPED_T | JOINTED | SECURE, "s", strings[13]); for (int i = 0; i < 15 && strings[i]; i++) { for (unsigned int j = total = 0; strings[i] && j < st_length_get(strings[i]); j++) { total += *(st_char_get(strings[i]) + j); } if (total != 5366) { result = false; } } if (result) { strings[15] = st_merge(MANAGED_T | JOINTED | HEAP, "snsnsnsnsnsnsnsnsnsnsnsnsnsnsnsn", constant, "\n", strings[0], "\n", strings[1], "\n", strings[2], "\n", strings[3], "\n", strings[4], "\n", strings[5], "\n", strings[6], "\n", strings[7], "\n", strings[8], "\n", strings[9], "\n", strings[10], "\n", strings[11], "\n", strings[12], "\n", strings[13], "\n", strings[14], "\n"); for (unsigned int i = total = 0; strings[15] && i < st_length_get(strings[15]); i++) { total += *(st_char_get(strings[15]) + i); } if (total != (5376lu * 16lu)) { result = false; } } log_print("%28.28s = %s", "merged", result ? "passed" : "failed"); for (int i = 0; i < 16; i++) { if (strings[i]) st_free(strings[i]); } return result; }
//----------------------------------------------------------------------------- // either log directly to the file (slow), or buffer and set an event. void logger(logging_t *log, short int level, const char *format, ...) { char buffer[30], timebuf[48]; struct timeval tv; time_t curtime; va_list ap; int redo; int n; struct timeval t = {.tv_sec = DEFAULT_LOG_TIMER, .tv_usec = 0}; assert(log); assert(level >= 0); assert(format); // first check if we should be logging this entry if (level <= log->loglevel && log->filename) { // calculate the time. gettimeofday(&tv, NULL); curtime=tv.tv_sec; strftime(buffer, 30, "%Y-%m-%d %T.", localtime(&curtime)); snprintf(timebuf, 48, "%s%06ld ", buffer, tv.tv_usec); assert(log->buildbuf); assert(log->buildbuf->length == 0); assert(log->buildbuf->max > 0); // process the string. Apply directly to the buildbuf. If buildbuf is not // big enough, increase the size and do it again. redo = 1; while (redo) { va_start(ap, format); n = vsnprintf(log->tmpbuf->data, log->tmpbuf->max, format, ap); va_end(ap); assert(n > 0); if (n > log->tmpbuf->max) { // there was not enough space, so we need to increase it, and try again. expbuf_shrink(log->tmpbuf, n + 1); } else { assert(n <= log->tmpbuf->max); log->tmpbuf->length = n; redo = 0; } } // we now have the built string in our tmpbuf. We need to add it to the complete built buffer. assert(log->tmpbuf->length > 0); assert(log->buildbuf->length == 0); expbuf_set(log->buildbuf, timebuf, strlen(timebuf)); expbuf_add(log->buildbuf, log->tmpbuf->data, log->tmpbuf->length); expbuf_add(log->buildbuf, "\n", 1); // if evbase is NULL, then we will need to write directly. if (log->evbase == NULL) { if (log->outbuf->length > 0) { log_print(log, log->outbuf); expbuf_free(log->outbuf); } log_print(log, log->buildbuf); } else { // we have an evbase, so we need to add our build data to the outbuf. expbuf_add(log->outbuf, log->buildbuf->data, log->buildbuf->length); // if the log_event is null, then we need to set the timeout event. if (log->log_event == NULL) { #if (_EVENT_NUMERIC_VERSION < 0x02000000) log->log_event = calloc(1, sizeof(*log->log_event)); evtimer_set(log->log_event, log_handler, (void *) log); event_base_set(log->evbase, log->log_event); #else log->log_event = evtimer_new(log->evbase, log_handler, (void *) log); #endif assert(log->log_event); evtimer_add(log->log_event, &t); } } expbuf_clear(log->buildbuf); } } void log_inclevel(logging_t *log) { assert(log); log->loglevel ++; }
int main(void) { if (!mm_sec_start()) { log_print("Secure memory pool did not start correctly."); return 1; } else if (sizeof(stringer_t) != 4) { log_print("The string options variable should be 4 bytes/32 bits."); return 1; } /*chr_t *data = "Hello world."; size_t len = ns_length_get(data); stringer_t *place = PLACER(data, len); log_print("%.*s\n%.*s\n", st_length_int(PLACER(data, len)), st_char_get(PLACER(data, len)), st_length_int((stringer_t *)place), st_char_get((stringer_t *)place)); if (st_cmp_cs_eq(PLACER(st_data_get(constant), st_length_get(constant)), constant) || memcmp("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", st_data_get(constant), st_length_get(constant))) exit(1);*/ // Since were intentionally going to trigger errors, disable standard out while doing so. log_disable(); // Check that we can't specify a length greater than the available buffer. if (!check_string_logic(MANAGED_T | CONTIGUOUS | HEAP) || !check_string_logic(MANAGED_T | JOINTED | HEAP) || !check_string_logic(MAPPED_T | JOINTED | HEAP)) { log_print("--------------------------------------- LOGIC -------------------------------------------\n"); log_print("String logic checks failed."); return 1; } log_enable(); log_print("--------------------------------------- CONSTANT ----------------------------------------\n%28.28s = %.*s", "constant[fixed+contiguous]", st_length_int(constant), st_char_get(constant)); log_print("--------------------------------------- IMPORT ------------------------------------------"); if (!check_string_import()) { log_print("Import check failed."); return 1; } // Begin allocation checks. log_print("--------------------------------------- ALLOCATION --------------------------------------"); if (!check_string_alloc("nuller[heap+contiguous]", NULLER_T | CONTIGUOUS | HEAP) || !check_string_alloc("block[heap+contiguous]", BLOCK_T | CONTIGUOUS | HEAP) || !check_string_alloc("managed[heap+contiguous]", MANAGED_T | CONTIGUOUS | HEAP)) { log_print("Standard allocation checks failed."); return 1; } if (!check_string_alloc("nuller[heap+jointed]", NULLER_T | JOINTED | HEAP) || !check_string_alloc("block[heap+jointed]", BLOCK_T | JOINTED | HEAP) || !check_string_alloc("managed[heap+jointed]", MANAGED_T | JOINTED | HEAP) || !check_string_alloc("mapped[heap+jointed]", MAPPED_T | JOINTED | HEAP)) { log_print("Jointed allocation checks failed."); return 1; } if (!check_string_alloc("nuller[secure+contiguous]", NULLER_T | CONTIGUOUS | SECURE) || !check_string_alloc("block[secure+contiguous]", BLOCK_T | CONTIGUOUS | SECURE) || !check_string_alloc("managed[secure+contiguous]", MANAGED_T | CONTIGUOUS | SECURE)) { log_print("Secure allocation of contiguous types failed."); return 1; } if (!check_string_alloc("nuller[secure+jointed]", NULLER_T | JOINTED | SECURE) || !check_string_alloc("block[secure+jointed]", BLOCK_T | JOINTED | SECURE) || !check_string_alloc("managed[secure+jointed]", MANAGED_T | JOINTED | SECURE) || !check_string_alloc("mapped[secure+jointed]", MAPPED_T | JOINTED | SECURE)) { log_print("Secure allocation of jointed types failed."); return 1; } // Begin reallocation checks. log_print("-------------------------------------- REALLOCATION -------------------------------------"); if (!check_string_realloc("nuller[heap+contiguous]", NULLER_T | CONTIGUOUS | HEAP) || !check_string_realloc("block[heap+contiguous]", BLOCK_T | CONTIGUOUS | HEAP) || !check_string_realloc("managed[heap+contiguous]", MANAGED_T | CONTIGUOUS | HEAP)) { log_print("Standard reallocation checks failed."); return 1; } if (!check_string_realloc("nuller[heap+jointed]", NULLER_T | JOINTED | HEAP) || !check_string_realloc("block[heap+jointed]", BLOCK_T | JOINTED | HEAP) || !check_string_realloc("managed[heap+jointed]", MANAGED_T | JOINTED | HEAP) || !check_string_realloc("mapped[heap+jointed]", MAPPED_T | JOINTED | HEAP)) { log_print("Jointed reallocation checks failed."); return 1; } if (!check_string_realloc("nuller[secure+contiguous]", NULLER_T | CONTIGUOUS | SECURE) || !check_string_realloc("block[secure+contiguous]", BLOCK_T | CONTIGUOUS | SECURE) || !check_string_realloc("managed[secure+contiguous]", MANAGED_T | CONTIGUOUS | SECURE)) { log_print("Secure reallocation of contiguous types failed."); return 1; } if (!check_string_realloc("nuller[secure+jointed]", NULLER_T | JOINTED | SECURE) || !check_string_realloc("block[secure+jointed]", BLOCK_T | JOINTED | SECURE) || !check_string_realloc("managed[secure+jointed]", MANAGED_T | JOINTED | SECURE) || !check_string_realloc("mapped[secure+jointed]", MAPPED_T | JOINTED | SECURE)) { log_print("Secure reallocation of jointed types failed."); return 1; } // Begin duplication checks. log_print("-------------------------------------- DUPLICATION --------------------------------------"); if (!check_string_dupe("nuller[heap+contiguous]", NULLER_T | CONTIGUOUS | HEAP) || !check_string_dupe("block[heap+contiguous]", BLOCK_T | CONTIGUOUS | HEAP) || !check_string_dupe("managed[heap+contiguous]", MANAGED_T | CONTIGUOUS | HEAP)) { log_print("Standard duplication checks failed."); return 1; } if (!check_string_dupe("nuller[heap+jointed]", NULLER_T | JOINTED | HEAP) || !check_string_dupe("block[heap+jointed]", BLOCK_T | JOINTED | HEAP) || !check_string_dupe( "managed[heap+jointed]", MANAGED_T | JOINTED | HEAP) || !check_string_dupe("mapped[heap+jointed]", MAPPED_T | JOINTED | HEAP)) { log_print("Jointed duplication checks failed."); return 1; } if (!check_string_dupe("nuller[secure+contiguous]", NULLER_T | CONTIGUOUS | SECURE) || !check_string_dupe("block[secure+contiguous]", BLOCK_T | CONTIGUOUS | SECURE) || !check_string_dupe("managed[secure+contiguous]", MANAGED_T | CONTIGUOUS | SECURE)) { log_print("Secure duplication of contiguous types failed."); return 1; } if (!check_string_dupe("nuller[secure+jointed]", NULLER_T | JOINTED | SECURE) || !check_string_dupe("block[secure+jointed]", BLOCK_T | JOINTED | SECURE) || !check_string_dupe("managed[secure+jointed]", MANAGED_T | JOINTED | SECURE) || !check_string_dupe("mapped[secure+jointed]", MAPPED_T | JOINTED | SECURE)) { log_print("Secure duplication of jointed types failed."); return 1; } log_print("-------------------------------------- MERGE --------------------------------------------"); if (!check_string_merge()) { log_print("The merge function failed."); return 1; } log_print("-------------------------------------- PRINT --------------------------------------------"); if (!check_string_print()) { log_print("The print function failed."); return 1; } mm_sec_stop(); log_print("---------------------------------------- FINISHED ---------------------------------------"); return 0; }
static void handle_connection (mailbox_id_type reply_mailbox_id, realtek_device_type *device) { message_parameter_type message_parameter; ipc_structure_type ipc_structure; bool done = FALSE; unsigned int data_size = 1024; u32 *data; memory_allocate ((void **) &data, data_size); /* Accept the connection. */ ipc_structure.output_mailbox_id = reply_mailbox_id; ipc_connection_establish (&ipc_structure); message_parameter.data = data; message_parameter.block = TRUE; message_parameter.protocol = IPC_PROTOCOL_ETHERNET; while (!done) { message_parameter.message_class = IPC_CLASS_NONE; message_parameter.length = data_size; if (ipc_receive (ipc_structure.input_mailbox_id, &message_parameter, &data_size) != STORM_RETURN_SUCCESS) { continue; } switch (message_parameter.message_class) { case IPC_ETHERNET_REGISTER_TARGET: { /* FIXME: Check if the protocol is already registered */ device->target[device->number_of_targets].mailbox_id = ipc_structure.output_mailbox_id; device->target[device->number_of_targets].protocol_type = system_byte_swap_u16 (data[0]); device->number_of_targets++; break; } case IPC_ETHERNET_PACKET_SEND: { if (!realtek_start_transmit ((u8 *) data, message_parameter.length, device)) { log_print (&log_structure, LOG_URGENCY_ERROR, "Failed to send an ethernet packet."); /* FIXME: Do something. */ } break; } case IPC_ETHERNET_ADDRESS_GET: { memory_copy (data, &device->ethernet_address, 6); message_parameter.length = 6; system_call_mailbox_send (ipc_structure.output_mailbox_id, &message_parameter); break; } default: { log_print (&log_structure, LOG_URGENCY_ERROR, "Unknown IPC command received."); break; } } } }
int vgextend(struct cmd_context *cmd, int argc, char **argv) { char *vg_name; struct volume_group *vg = NULL; int r = ECMD_FAILED; struct pvcreate_params pp; if (!argc) { log_error("Please enter volume group name and " "physical volume(s)"); return EINVALID_CMD_LINE; } vg_name = skip_dev_dir(cmd, argv[0], NULL); argc--; argv++; if (arg_count(cmd, metadatacopies_ARG)) { log_error("Invalid option --metadatacopies, " "use --pvmetadatacopies instead."); return EINVALID_CMD_LINE; } pvcreate_params_set_defaults(&pp); if (!pvcreate_params_validate(cmd, argc, argv, &pp)) { return EINVALID_CMD_LINE; } log_verbose("Checking for volume group \"%s\"", vg_name); vg = vg_read_for_update(cmd, vg_name, NULL, 0); if (vg_read_error(vg)) { vg_release(vg); stack; return ECMD_FAILED; } if (!lock_vol(cmd, VG_ORPHANS, LCK_VG_WRITE)) { log_error("Can't get lock for orphan PVs"); unlock_and_release_vg(cmd, vg, vg_name); return ECMD_FAILED; } if (!archive(vg)) goto_bad; /* extend vg */ if (!vg_extend(vg, argc, argv, &pp)) goto_bad; /* ret > 0 */ log_verbose("Volume group \"%s\" will be extended by %d new " "physical volumes", vg_name, argc); /* store vg on disk(s) */ if (!vg_write(vg) || !vg_commit(vg)) goto_bad; backup(vg); log_print("Volume group \"%s\" successfully extended", vg_name); r = ECMD_PROCESSED; bad: unlock_vg(cmd, VG_ORPHANS); unlock_and_release_vg(cmd, vg, vg_name); return r; }
static void handle_8139 (pci_device_info_type *device_info) { unsigned int counter; u16 port_base = MAX_U16; u16 ports = 0; realtek_device_type *device; unsigned int physical, physical_index; ipc_structure_type ipc_structure; system_thread_name_set ("Initialising"); for (counter = 0; counter < PCI_NUMBER_OF_RESOURCES; counter++) { if ((device_info->resource[counter].flags & PCI_RESOURCE_IO) != 0) { port_base = device_info->resource[counter].start; ports = (device_info->resource[counter].end - device_info->resource[counter].start + 1); } } if (port_base == MAX_U16) { log_print_formatted (&log_structure, LOG_URGENCY_ERROR, "No port range found -- hardware possibly broken or incompatible?"); return; } system_call_port_range_register (port_base, ports, "Realtek 8139"); memory_allocate ((void **) &device, sizeof (realtek_device_type)); device->port_base = port_base; device->irq = device_info->irq; /* Initialise the adapter. */ system_port_out_u8 (port_base + Config1, 0x00); if (read_eeprom (port_base, 0) != 0xFFFF) { for (counter = 0; counter < 3; counter++) { ((u16 *)(device->ethernet_address))[counter] = system_little_endian_to_native_u16 (read_eeprom (port_base, counter + 7)); } } else { for (counter = 0; counter < 6; counter++) { device->ethernet_address[counter] = system_port_in_u8 (port_base + MAC0 + counter); } } log_print_formatted (&log_structure, LOG_URGENCY_INFORMATIVE, "Realtek 8139 at 0x%X, IRQ %d, ethernet address: %02X:%02X:%02X:%02X:%02X:%02X", port_base, device_info->irq, device->ethernet_address[0], device->ethernet_address[1], device->ethernet_address[2], device->ethernet_address[3], device->ethernet_address[4], device->ethernet_address[5]); /* Find the connected MII transceivers. */ for (physical = 0, physical_index = 0; physical < 32 && physical_index < sizeof (device->mii_address); physical++) { int mii_status = mdio_read (port_base, physical, 1); if (mii_status != 0xFFFF && mii_status != 0x0000) { device->mii_address[physical_index] = physical; physical_index++; log_print_formatted (&log_structure, LOG_URGENCY_INFORMATIVE, "MII transceiver found at address %d.", physical); } } if (physical_index == 0) { if (realtek_debug > 1) { log_print_formatted (&log_structure, LOG_URGENCY_INFORMATIVE, "No MII transceivers found! Assuming SYM " "transceiver."); } device->mii_address[0] = -1; } /* Soft reset the chip. */ system_port_out_u8 (port_base + ChipCommand, CommandReset); pci_allocate_buffer ((void **) &device->tx_buffers_dma, (void **) &device->tx_buffers, TX_BUFFER_SIZE * NUMBER_OF_TX_DESCRIPTORS); pci_allocate_buffer ((void **) &device->rx_ring_dma, (void **) &device->rx_ring, RX_BUFFER_LENGTH + 16); device->tx_full = FALSE; device->current_rx = 0; device->dirty_tx = device->current_tx = 0; for (counter = 0; counter < NUMBER_OF_TX_DESCRIPTORS; counter++) { device->tx_buffer[counter] = &device->tx_buffers[counter * TX_BUFFER_SIZE]; } /* Check that the chip has finished the reset. */ for (counter = 0; counter < 1000; counter++) { if ((system_port_in_u8 (port_base + ChipCommand) & CommandReset) == 0) { break; } } /* Must enable Tx/Rx before setting transfer thresholds! */ system_port_out_u8 (port_base + ChipCommand, CommandRxEnable | CommandTxEnable); system_port_out_u32 (port_base + RxConfig, (RX_FIFO_THRESHOLD << 13) | (RX_BUFFER_LENGTH_INDEX << 11) | (RX_DMA_BURST << 8)); system_port_out_u32 (port_base + TxConfig, (TX_DMA_BURST << 8) | 0x03000000); if (device->mii_address[0] >= 0) { u16 mii_reg5 = mdio_read (port_base, device->mii_address[0], 5); if (mii_reg5 == 0xffff) { } else if ((mii_reg5 & 0x0100) == 0x0100 || (mii_reg5 & 0x00C0) == 0x0040) { device->full_duplex = TRUE; } log_print_formatted (&log_structure, LOG_URGENCY_INFORMATIVE, "Setting %s%s-duplex based on" " auto-negotiated partner ability %4.4x.\n", mii_reg5 == 0 ? "" : ((mii_reg5 & 0x0180) != 0) ? "100 Mbps " : "10 Mbps ", device->full_duplex ? "full" : "half", mii_reg5); } system_port_out_u8 (port_base + Config9346, 0xC0); system_port_out_u8 (port_base + Config1, device->full_duplex ? 0x60 : 0x20); system_port_out_u8 (port_base + Config9346, 0x00); system_port_out_u32 (port_base + RxBuffer, (u32) device->rx_ring_dma); /* Start the chip's Tx and Rx process. */ system_port_out_u32 (port_base + RxMissed, 0); set_rx_mode (device); system_port_out_u8 (port_base + ChipCommand, CommandRxEnable | CommandTxEnable); /* Enable all known interrupts by setting the interrupt mask. */ system_port_out_u16 (port_base + InterruptMask, PCIError | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOverrun | TxError | TxOK | RxError | RxOK); if (system_thread_create () == SYSTEM_RETURN_THREAD_NEW) { system_thread_name_set ("IRQ handler"); if (system_call_irq_register (device_info->irq, "Realtek 8139") != SYSTEM_RETURN_SUCCESS) { log_print_formatted (&log_structure, LOG_URGENCY_EMERGENCY, "Couldn't set up IRQ handler"); return; } /* Loop and handle interrupts. */ while (TRUE) { int bogus_count = max_interrupt_work; unsigned status, link_changed = 0; system_call_irq_wait (device->irq); do { status = system_port_in_u16 (port_base + InterruptStatus); /* Acknowledge all of the current interrupt sources ASAP, but an first get an additional status bit from CSCR. */ if ((status & RxUnderrun) && system_port_in_u16 (port_base + CSCR) & CSCR_LinkChangeBit) { link_changed = 1; } system_port_out_u16 (port_base + InterruptStatus, status); if ((status & (PCIError | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOverrun | TxError | TxOK | RxError | RxOK)) == 0) { break; } /* Rx interrupt. */ if ((status & (RxOK | RxUnderrun | RxOverflow | RxFIFOOverrun)) != 0) { realtek_receive (device); } if ((status & (TxOK | TxError)) != 0) { unsigned int dirty_tx = device->dirty_tx; while (device->current_tx - dirty_tx > 0) { int entry = dirty_tx % NUMBER_OF_TX_DESCRIPTORS; int txstatus = system_port_in_u32 (port_base + TxStatus0 + entry * 4); if ((txstatus & (TxStatusOK | TxUnderrun | TxAborted)) == 0) { /* It still hasn't been transmitted. */ break; } /* Note: TxCarrierLost is always asserted at 100 Mbps. */ if ((txstatus & (TxOutOfWindow | TxAborted)) != 0) { /* There was an major error, log it. */ // device->stats.tx_errors++; if ((txstatus & TxAborted) != 0) { // tp->stats.tx_aborted_errors++; system_port_out_u32 (port_base + TxConfig, (TX_DMA_BURST << 8) | 0x03000001); } if ((txstatus & TxCarrierLost) != 0) { // tp->stats.tx_carrier_errors++; } if ((txstatus & TxOutOfWindow) != 0) { // tp->stats.tx_window_errors++; } } else { if ((txstatus & TxUnderrun) != 0) { /* Add 64 to the Tx FIFO threshold. */ if (device->tx_flag < 0x00300000) { device->tx_flag += 0x00020000; } // tp->stats.tx_fifo_errors++; } // tp->stats.collisions += (txstatus >> 24) & 15; // tp->stats.tx_bytes += txstatus & 0x7ff; // tp->stats.tx_packets++; } // if (tp->tx_info[entry].mapping != 0) // { // pci_unmap_single (tp->pdev, // tp->tx_info[entry].mapping, // tp->tx_info[entry].skb->len, // PCI_DMA_TODEVICE); // tp->tx_info[entry].mapping = 0; // } /* Free the original skb. */ // dev_kfree_skb_irq (tp->tx_info[entry].skb); // tp->tx_info[entry].skb = NULL; if (device->tx_full) { /* The ring is no longer full, wake the queue. */ device->tx_full = FALSE; // netif_wake_queue(dev); } dirty_tx++; } device->dirty_tx = dirty_tx; } /* Check uncommon events with one test. */ if ((status & (PCIError | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOverrun | TxError | RxError)) != 0) { if (realtek_debug > 2) { log_print_formatted (&log_structure, LOG_URGENCY_WARNING, "Abnormal interrupt, status %8.8x.\n", status); } if (status == 0xFFFFFFFF) { break; } /* Update the error count. */ // tp->stats.rx_missed_errors += inl(port_base + RxMissed); system_port_out_u32 (port_base + RxMissed, 0); if ((status & RxUnderrun) != 0 && link_changed) { /* Really link-change on new chips. */ int lpar = system_port_in_u16 (port_base + NWayLPAR); int duplex = (lpar & 0x0100) || (lpar & 0x01C0) == 0x0040; if (device->full_duplex != duplex) { device->full_duplex = duplex; system_port_out_u8 (port_base + Config9346, 0xC0); system_port_out_u8 (port_base + Config1, device->full_duplex ? 0x60 : 0x20); system_port_out_u8 (port_base + Config9346, 0x00); } status &= ~RxUnderrun; } if ((status & (RxUnderrun | RxOverflow | RxError | RxFIFOOverrun)) != 0) { // tp->stats.rx_errors++; } if ((status & (PCSTimeout)) != 0) { // tp->stats.rx_length_errors++; } if ((status & (RxUnderrun | RxFIFOOverrun)) != 0) { // tp->stats.rx_fifo_errors++; } if ((status & RxOverflow) != 0) { // tp->stats.rx_over_errors++; device->current_rx = (system_port_in_u16 (port_base + RxBufferAddress) % RX_BUFFER_LENGTH); system_port_out_u16 (port_base + RxBufferPointer, device->current_rx - 16); } if ((status & PCIError) != 0) { log_print (&log_structure, LOG_URGENCY_WARNING, "PCI Bus error."); } } if (--bogus_count < 0) { log_print_formatted (&log_structure, LOG_URGENCY_WARNING, "Too much work at interrupt, " "InterruptStatus = 0x%4.4x.", status); /* Clear all interrupt sources. */ system_port_out_u16 (port_base + InterruptStatus, 0xFFFF); break; } } while (TRUE); system_call_irq_acknowledge (device->irq); } } /* Now, use the remaining thread for the service handler. */ system_thread_name_set ("Service handler"); /* Create the service. */ if (ipc_service_create ("ethernet", &ipc_structure, &empty_tag) != IPC_RETURN_SUCCESS) { log_print (&log_structure, LOG_URGENCY_EMERGENCY, "Couldn't create ethernet service."); return; } while (TRUE) { mailbox_id_type reply_mailbox_id; ipc_service_connection_wait (&ipc_structure); reply_mailbox_id = ipc_structure.output_mailbox_id; if (system_thread_create () == SYSTEM_RETURN_THREAD_NEW) { system_call_thread_name_set ("Handling connection"); handle_connection (reply_mailbox_id, device); } } }
static gint smtp_auth_recv(SMTPSession *session, const gchar *msg) { gchar buf[MESSAGEBUFSIZE], *tmp; switch (session->auth_type) { case SMTPAUTH_LOGIN: session->state = SMTP_AUTH_LOGIN_USER; if (!strncmp(msg, "334 ", 4)) { tmp = g_base64_encode(session->user, strlen(session->user)); if (session_send_msg(SESSION(session), SESSION_MSG_NORMAL, tmp) < 0) { g_free(tmp); return SM_ERROR; } g_free(tmp); log_print(LOG_PROTOCOL, "ESMTP> [USERID]\n"); } else { /* Server rejects AUTH */ if (session_send_msg(SESSION(session), SESSION_MSG_NORMAL, "*") < 0) return SM_ERROR; log_print(LOG_PROTOCOL, "ESMTP> *\n"); } break; case SMTPAUTH_CRAM_MD5: session->state = SMTP_AUTH_CRAM_MD5; if (!strncmp(msg, "334 ", 4)) { gchar *response; gchar *response64; gchar *challenge; gsize challengelen; guchar hexdigest[33]; challenge = g_base64_decode_zero(msg + 4, &challengelen); log_print(LOG_PROTOCOL, "ESMTP< [Decoded: %s]\n", challenge); g_snprintf(buf, sizeof(buf), "%s", session->pass); md5_hex_hmac(hexdigest, challenge, challengelen, buf, strlen(session->pass)); g_free(challenge); response = g_strdup_printf ("%s %s", session->user, hexdigest); log_print(LOG_PROTOCOL, "ESMTP> [Encoded: %s]\n", response); response64 = g_base64_encode(response, strlen(response)); g_free(response); if (session_send_msg(SESSION(session), SESSION_MSG_NORMAL, response64) < 0) { g_free(response64); return SM_ERROR; } log_print(LOG_PROTOCOL, "ESMTP> %s\n", response64); g_free(response64); } else { /* Server rejects AUTH */ if (session_send_msg(SESSION(session), SESSION_MSG_NORMAL, "*") < 0) return SM_ERROR; log_print(LOG_PROTOCOL, "ESMTP> *\n"); } break; case SMTPAUTH_DIGEST_MD5: default: /* stop smtp_auth when no correct authtype */ if (session_send_msg(SESSION(session), SESSION_MSG_NORMAL, "*") < 0) return SM_ERROR; log_print(LOG_PROTOCOL, "ESMTP> *\n"); break; } return SM_OK; }
static void parse_args (int argc, char *argv[]) { int ch; char *ep; #ifdef USE_DEBUG int cls, level; int do_packetlog = 0; #endif while ((ch = getopt (argc, argv, "46c:dD:f:i:np:P:Ll:r:R:v")) != -1) { switch (ch) { case '4': bind_family |= BIND_FAMILY_INET4; break; case '6': bind_family |= BIND_FAMILY_INET6; break; case 'c': conf_path = optarg; break; case 'd': debug++; break; #ifdef USE_DEBUG case 'D': if (sscanf (optarg, "%d=%d", &cls, &level) != 2) { if (sscanf (optarg, "A=%d", &level) == 1) { for (cls = 0; cls < LOG_ENDCLASS; cls++) log_debug_cmd (cls, level); } else log_print ("parse_args: -D argument unparseable: %s", optarg); } else log_debug_cmd (cls, level); break; #endif /* USE_DEBUG */ case 'f': ui_fifo = optarg; break; case 'i': pid_file = optarg; break; case 'n': app_none++; break; case 'p': udp_default_port = optarg; break; case 'P': udp_bind_port = optarg; break; #ifdef USE_DEBUG case 'l': pcap_file = optarg; /* Fallthrough intended. */ case 'L': do_packetlog++; break; #endif /* USE_DEBUG */ case 'r': seed = strtoul (optarg, &ep, 0); srandom (seed); if (*ep != '\0') log_fatal ("parse_args: invalid numeric arg to -r (%s)", optarg); regrand = 1; break; case 'R': report_file = optarg; break; case 'v': verbose_logging = 1; break; case '?': default: usage (); } } argc -= optind; argv += optind; #ifdef USE_DEBUG if (do_packetlog && !pcap_file) pcap_file = PCAP_FILE_DEFAULT; #endif }
struct stat_cache_value *stat_cache_value_get(stat_cache_t *cache, const char *path, bool skip_freshness_check) { struct stat_cache_value *value = NULL; char *key; leveldb_readoptions_t *options; size_t vallen; char *errptr = NULL; //void *f; time_t current_time; key = path2key(path, false); log_print(LOG_DEBUG, "CGET: %s", key); options = leveldb_readoptions_create(); value = (struct stat_cache_value *) leveldb_get(cache, options, key, strlen(key) + 1, &vallen, &errptr); leveldb_readoptions_destroy(options); free(key); //log_print(LOG_DEBUG, "Mode: %04o", value->st.st_mode); if (errptr != NULL) { log_print(LOG_ERR, "leveldb_get error: %s", errptr); free(errptr); return NULL; } if (value == NULL) { log_print(LOG_DEBUG, "stat_cache_value_get miss on path: %s", path); return NULL; } if (vallen != sizeof(struct stat_cache_value)) { log_print(LOG_ERR, "Length %lu is not expected length %lu.", vallen, sizeof(struct stat_cache_value)); } if (!skip_freshness_check) { current_time = time(NULL); // First, check against the stat item itself. //log_print(LOG_DEBUG, "Current time: %lu", current_time); if (current_time - value->updated > CACHE_TIMEOUT) { char *directory; time_t directory_updated; int is_dir; log_print(LOG_DEBUG, "Stat entry %s is %lu seconds old.", path, current_time - value->updated); // If that's too old, check the last update of the directory. directory = strip_trailing_slash(ne_path_parent(path), &is_dir); directory_updated = stat_cache_read_updated_children(cache, directory); //log_print(LOG_DEBUG, "Directory contents for %s are %lu seconds old.", directory, (current_time - directory_updated)); free(directory); if (current_time - directory_updated > CACHE_TIMEOUT) { log_print(LOG_DEBUG, "%s is too old.", path); free(value); return NULL; } } } /* if ((f = file_cache_get(path))) { value->st.st_size = file_cache_get_size(f); file_cache_unref(cache, f); } */ //print_stat(&value->st, "CGET"); return value; }
int main (int argc, char *argv[]) { fd_set *rfds, *wfds; int n, m; size_t mask_size; struct timeval tv, *timeout; /* Make sure init() won't alloc fd 0, 1 or 2, as daemon() will close them. */ for (n = 0; n <= 2; n++) if (fcntl (n, F_GETFL, 0) == -1 && errno == EBADF) (void)open ("/dev/null", n ? O_WRONLY : O_RDONLY, 0); /* Log cmd line parsing and initialization errors to stderr. */ log_to (stderr); parse_args (argc, argv); log_init (); /* Do a clean daemon shutdown on TERM reception. (Needed by monitor). */ signal (SIGTERM, daemon_shutdown_now); if (debug) signal (SIGINT, daemon_shutdown_now); #if defined (USE_PRIVSEP) if (monitor_init ()) { /* The parent, with privileges. */ if (!debug) if (daemon (0, 0)) log_fatal ("main [priv]: daemon (0, 0) failed"); /* Enter infinite monitor loop. */ monitor_loop (debug); exit (0); /* Never reached. */ } /* Child process only from this point on, no privileges left. */ #endif init (); if (!debug) { if (daemon (0, 0)) log_fatal ("main: daemon (0, 0) failed"); /* Switch to syslog. */ log_to (0); } write_pid_file (); /* Reinitialize on HUP reception. */ signal (SIGHUP, sighup); /* Report state on USR1 reception. */ signal (SIGUSR1, sigusr1); /* Rehash soft expiration timers on USR2 reception. */ signal (SIGUSR2, sigusr2); #if defined (USE_DEBUG) /* If we wanted IKE packet capture to file, initialize it now. */ if (pcap_file != 0) log_packet_init (pcap_file); #endif /* Allocate the file descriptor sets just big enough. */ n = getdtablesize (); mask_size = howmany (n, NFDBITS) * sizeof (fd_mask); rfds = (fd_set *)malloc (mask_size); if (!rfds) log_fatal ("main: malloc (%lu) failed", (unsigned long)mask_size); wfds = (fd_set *)malloc (mask_size); if (!wfds) log_fatal ("main: malloc (%lu) failed", (unsigned long)mask_size); while (1) { /* If someone has sent SIGHUP to us, reconfigure. */ if (sighupped) { log_print ("SIGHUP received"); reinit (); sighupped = 0; } /* and if someone sent SIGUSR1, do a state report. */ if (sigusr1ed) { log_print ("SIGUSR1 received"); report (); } /* and if someone sent SIGUSR2, do a timer rehash. */ if (sigusr2ed) { log_print ("SIGUSR2 received"); rehash_timers (); } /* * and if someone set 'sigtermed' (SIGTERM or via the UI), this * indicated we should start a shutdown of the daemon. * * Note: Since _one_ message is sent per iteration of this enclosing * while-loop, and we want to send a number of DELETE notifications, * we must loop atleast this number of times. The daemon_shutdown() * function starts by queueing the DELETEs, all other calls just * increments the 'sigtermed' variable until it reaches a "safe" * value, and the daemon exits. */ if (sigtermed) daemon_shutdown (); /* Setup the descriptors to look for incoming messages at. */ memset (rfds, 0, mask_size); n = transport_fd_set (rfds); FD_SET (ui_socket, rfds); if (ui_socket + 1 > n) n = ui_socket + 1; /* * XXX Some day we might want to deal with an abstract application * class instead, with many instantiations possible. */ if (!app_none && app_socket >= 0) { FD_SET (app_socket, rfds); if (app_socket + 1 > n) n = app_socket + 1; } /* Setup the descriptors that have pending messages to send. */ memset (wfds, 0, mask_size); m = transport_pending_wfd_set (wfds); if (m > n) n = m; /* Find out when the next timed event is. */ timeout = &tv; timer_next_event (&timeout); n = select (n, rfds, wfds, 0, timeout); if (n == -1) { if (errno != EINTR) { log_error ("select"); /* * In order to give the unexpected error condition time to * resolve without letting this process eat up all available CPU * we sleep for a short while. */ sleep (1); } } else if (n) { transport_handle_messages (rfds); transport_send_messages (wfds); if (FD_ISSET (ui_socket, rfds)) ui_handler (); if (!app_none && app_socket >= 0 && FD_ISSET (app_socket, rfds)) app_handler (); } timer_handle_expirations (); } }
int PlayerGetAFilterFormat(const char *prop) { char value[1024]; int filter_fmt = 0; #ifndef USE_ARM_AUDIO_DEC /* check the dts/ac3 firmware status */ if(access("/system/etc/firmware/audiodsp_codec_ddp_dcv.bin",F_OK)){ #ifndef DOLBY_DAP_EN filter_fmt |= (FILTER_AFMT_AC3|FILTER_AFMT_EAC3); #endif } if(access("/system/etc/firmware/audiodsp_codec_dtshd.bin",F_OK) ){ filter_fmt |= FILTER_AFMT_DTS; } #else if(access("/system/lib/libstagefright_soft_dcvdec.so",F_OK)){ #ifndef DOLBY_DAP_EN filter_fmt |= (FILTER_AFMT_AC3|FILTER_AFMT_EAC3); #endif } if(access("/system/lib/libstagefright_soft_dtshd.so",F_OK) ){ filter_fmt |= FILTER_AFMT_DTS; } #endif if (GetSystemSettingString(prop, value, NULL) > 0) { log_print("[%s:%d]disable_adec=%s\n", __FUNCTION__, __LINE__, value); if (strstr(value,"mpeg") != NULL || strstr(value,"MPEG") != NULL) { filter_fmt |= FILTER_AFMT_MPEG; } if (strstr(value,"pcms16l") != NULL || strstr(value,"PCMS16L") != NULL) { filter_fmt |= FILTER_AFMT_PCMS16L; } if (strstr(value,"aac") != NULL || strstr(value,"AAC") != NULL) { filter_fmt |= FILTER_AFMT_AAC; } if (strstr(value,"ac3") != NULL || strstr(value,"AC#") != NULL) { filter_fmt |= FILTER_AFMT_AC3; } if (strstr(value,"alaw") != NULL || strstr(value,"ALAW") != NULL) { filter_fmt |= FILTER_AFMT_ALAW; } if (strstr(value,"mulaw") != NULL || strstr(value,"MULAW") != NULL) { filter_fmt |= FILTER_AFMT_MULAW; } if (strstr(value,"dts") != NULL || strstr(value,"DTS") != NULL) { filter_fmt |= FILTER_AFMT_DTS; } if (strstr(value,"pcms16b") != NULL || strstr(value,"PCMS16B") != NULL) { filter_fmt |= FILTER_AFMT_PCMS16B; } if (strstr(value,"flac") != NULL || strstr(value,"FLAC") != NULL) { filter_fmt |= FILTER_AFMT_FLAC; } if (strstr(value,"cook") != NULL || strstr(value,"COOK") != NULL) { filter_fmt |= FILTER_AFMT_COOK; } if (strstr(value,"pcmu8") != NULL || strstr(value,"PCMU8") != NULL) { filter_fmt |= FILTER_AFMT_PCMU8; } if (strstr(value,"adpcm") != NULL || strstr(value,"ADPCM") != NULL) { filter_fmt |= FILTER_AFMT_ADPCM; } if (strstr(value,"amr") != NULL || strstr(value,"AMR") != NULL) { filter_fmt |= FILTER_AFMT_AMR; } if (strstr(value,"raac") != NULL || strstr(value,"RAAC") != NULL) { filter_fmt |= FILTER_AFMT_RAAC; } if (strstr(value,"wma") != NULL || strstr(value,"WMA") != NULL) { filter_fmt |= FILTER_AFMT_WMA; } if (strstr(value,"wmapro") != NULL || strstr(value,"WMAPRO") != NULL) { filter_fmt |= FILTER_AFMT_WMAPRO; } if (strstr(value,"pcmblueray") != NULL || strstr(value,"PCMBLUERAY") != NULL) { filter_fmt |= FILTER_AFMT_PCMBLU; } if (strstr(value,"alac") != NULL || strstr(value,"ALAC") != NULL) { filter_fmt |= FILTER_AFMT_ALAC; } if (strstr(value,"vorbis") != NULL || strstr(value,"VORBIS") != NULL) { filter_fmt |= FILTER_AFMT_VORBIS; } if (strstr(value,"aac_latm") != NULL || strstr(value,"AAC_LATM") != NULL) { filter_fmt |= FILTER_AFMT_AAC_LATM; } if (strstr(value,"ape") != NULL || strstr(value,"APE") != NULL) { filter_fmt |= FILTER_AFMT_APE; } if (strstr(value,"eac3") != NULL || strstr(value,"EAC3") != NULL) { filter_fmt |= FILTER_AFMT_EAC3; } } log_print("[%s:%d]filter_afmt=%x\n", __FUNCTION__, __LINE__, filter_fmt); return filter_fmt; }
/** * Set Cwnd limit * @param connarg tcp_stat_connection pointer * @param group_arg tcp_stat group pointer * @param agentarg tcp_stat agent pointer * */ void setCwndlimit(tcp_stat_connection connarg, tcp_stat_group* grouparg, tcp_stat_agent* agentarg, Options* optionsarg) { #if USE_WEB100 web100_var *LimRwin, *yar; #elif USE_WEB10G struct estats_val yar; #endif u_int32_t limrwin_val; if (optionsarg->limit > 0) { log_print(1, "Setting Cwnd limit - "); #if USE_WEB100 if (connarg != NULL) { log_println(1, "Got web100 connection pointer for recvsfd socket\n"); char yuff[32]; web100_agent_find_var_and_group(agentarg, "CurMSS", &grouparg, &yar); web100_raw_read(yar, connarg, yuff); log_println(1, "MSS = %s, multiplication factor = %d", web100_value_to_text(web100_get_var_type(yar), yuff), optionsarg->limit); limrwin_val = optionsarg->limit * (atoi( web100_value_to_text(web100_get_var_type(yar), yuff))); web100_agent_find_var_and_group(agentarg, "LimRwin", &grouparg, &LimRwin); log_print(1, "now write %d to limit the Receive window", limrwin_val); web100_raw_write(LimRwin, connarg, &limrwin_val); #elif USE_WEB10G if (connarg != -1) { log_println(1, "Got web10g connection for recvsfd socket\n"); web10g_get_val(agentarg, connarg, "CurMSS", &yar); log_println(1, "MSS = %s, multiplication factor = %d", yar.uv32, optionsarg->limit); limrwin_val = optionsarg->limit * yar.uv32; log_print(1, "now write %d to limit the Receive window", limrwin_val); estats_write_var("LimRwin", limrwin_val, connarg, agentarg); #endif log_println(1, " --- Done"); } } } /** * Check if receiver is clogged and use decision to temporarily * stop sending packets. * @param nextseqtosend integer indicating the Next Sequence Number To Be Sent * @param lastunackedseq integer indicating the oldest un-acked sequence number * @return integer indicating whether buffer is clogged * */ int is_buffer_clogged(int nextseqtosend, int lastunackedseq) { int recclog = 0; if ((RECLTH << 2) < (nextseqtosend - lastunackedseq - 1)) { recclog = 1; } return recclog; }
/** main function. * * man Function * * @param argc : 파라미터 개수 * @param *argv[] : 파라미터 * * @return S32 * @see msrp_main.c * * @exception . * @note . **/ S32 main(S32 argc, S8 *argv[]) { S32 dRet; /**< 함수 Return 값 */ OFFSET offset; U8 *pNode; U8 *pNextNode; U8 *p, *data; S32 type, len, ismalloc; TEXT_INFO *pstTEXTINFO; U8 *pDATA; char vERSION[7] = "R3.0.0"; /* log_print 초기화 */ log_init(S_SSHM_LOG_LEVEL, getpid(), SEQ_PROC_A_MSRPT, LOG_PATH"/A_MSRPT", "A_MSRPT"); /* A_HTTP 초기화 */ if((dRet = dInitMSRPT(&pstMEMSINFO, &pstMSRPTHASH, &pstTIMERNINFO)) < 0) { log_print(LOGN_CRI, "F=%s:%s.%d dInitMSRPT dRet=%d", __FILE__, __FUNCTION__, __LINE__, dRet); exit(0); } if((dRet = set_version(S_SSHM_VERSION, SEQ_PROC_A_MSRPT, vERSION)) < 0 ) { log_print(LOGN_CRI, "SET_VERSION ERROR(RET=%d,IDX=%d,VER=%s)", dRet, SEQ_PROC_A_MSRPT, vERSION); } guiTimerValue = flt_info->stTimerInfo.usTimerInfo[PI_MSRP_TIMEOUT]; log_print(LOGN_CRI, "START MSRPT VER[%s] TRANSCNT[%d] TIMER[%d]", vERSION, MSRPT_TRANS_CNT, guiTimerValue); /* MAIN LOOP */ while(giStopFlag) { timerN_invoke(pstTIMERNINFO); if((offset = gifo_read(pstMEMSINFO, gpCIFO, SEQ_PROC_A_MSRPM)) > 0) { log_print(LOGN_INFO, "======================================================================"); /* DB LOG 전송을 목적으로 하는 NODE (삭제 하지 않고 전송하기 위함 )*/ pNode = nifo_ptr(pstMEMSINFO, offset); pNextNode = pNode; pstTEXTINFO = NULL; pDATA = NULL; do { p = pNextNode; while(p != NULL) { if((dRet = nifo_read_tlv_cont(pstMEMSINFO, pNextNode, (U32*)&type, (U32*)&len, &data, &ismalloc, &p)) < 0) break; log_print(LOGN_INFO, "####################################################################"); log_print(LOGN_INFO, "TYPE[%d][%s] LEN[%d] ISMALLOC[%s]", type, PrintType(type), len, (ismalloc == DEF_READ_MALLOC) ? "MALLOC MEM" : "ORIGIN MEM"); switch(type) { case ETH_DATA_NUM: if(pstTEXTINFO != NULL) { pDATA = &data[pstTEXTINFO->offset]; log_print(LOGN_INFO, "PACKET TYPE[%d]", type); log_print(LOGN_INFO, "DATA[%.*s]", pstTEXTINFO->len, pDATA); } else { log_print(LOGN_CRI, "RCV PACKET_DATA BUT NOT RCV TEXT_INFO"); } break; case TEXT_INFO_DEF_NUM: pstTEXTINFO = (TEXT_INFO *)data; log_print(LOGN_INFO, "TEXT_INFO TYPE[%d]", type); log_print(LOGN_INFO, "TEXT_INFO OFFSET[%ld]LEN[%d]S[%u.%u]U[%u.%u]A[%u.%u]", pstTEXTINFO->offset, pstTEXTINFO->len, pstTEXTINFO->uiStartTime, pstTEXTINFO->uiStartMTime, pstTEXTINFO->uiLastUpdateTime, pstTEXTINFO->uiLastUpdateMTime, pstTEXTINFO->uiAckTime, pstTEXTINFO->uiAckMTime); break; /* Ignore Case */ default: log_print(LOGN_INFO, "????? UNKNOWN TYPE[%d]", type); break; } if(ismalloc == DEF_READ_MALLOC){ free(data); } } pNextNode = (U8 *)nifo_entry(nifo_ptr(pstMEMSINFO, ((NIFO *)pNextNode)->nont.offset_next), NIFO, nont); } while(pNode != pNextNode); if((pstTEXTINFO != NULL) && (pDATA != NULL)) { if(dProcMSRPTTrans(pstMEMSINFO, pstMSRPTHASH, pstTIMERNINFO, pstTEXTINFO, pDATA) < 0) { } } nifo_node_delete(pstMEMSINFO, pNode); } else { usleep(0); } } FinishProgram(); return 0; }
static int stream_ts_init(play_para_t *p_para) { v_stream_info_t *vinfo = &p_para->vstream_info; a_stream_info_t *ainfo = &p_para->astream_info; s_stream_info_t *sinfo = &p_para->sstream_info; AVCodecContext *pCodecCtx; codec_para_t *codec ; int ret = CODEC_ERROR_NONE; codec = codec_alloc(); if (!codec) { return PLAYER_EMPTY_P; } MEMSET(codec, 0, sizeof(codec_para_t)); codec->noblock = !!p_para->buffering_enable; if (vinfo->has_video) { codec->has_video = 1; codec->video_type = vinfo->video_format; codec->video_pid = vinfo->video_pid; if ((codec->video_type == VFORMAT_H264) || (codec->video_type == VFORMAT_H264MVC)) { codec->am_sysinfo.format = vinfo->video_codec_type; codec->am_sysinfo.width = vinfo->video_width; codec->am_sysinfo.height = vinfo->video_height; codec->am_sysinfo.rate = vinfo->video_rate; if (p_para->pFormatCtx->pb && p_para->pFormatCtx->pb->is_slowmedia) { /* ts slow media, use idr framerate */ log_print("[%s:%d]Slow media detected for ts\n", __FUNCTION__, __LINE__); codec->am_sysinfo.param = USE_IDR_FRAMERATE; } } else if (codec->video_type == VFORMAT_VC1 || codec->video_type == VFORMAT_AVS) { codec->am_sysinfo.format = vinfo->video_codec_type; codec->am_sysinfo.width = vinfo->video_width; codec->am_sysinfo.height = vinfo->video_height; codec->am_sysinfo.rate = vinfo->video_rate; } } if (ainfo->has_audio) { codec->has_audio = 1; codec->audio_type = ainfo->audio_format; codec->audio_pid = ainfo->audio_pid; codec->audio_channels = ainfo->audio_channel; codec->audio_samplerate = ainfo->audio_samplerate; codec->switch_audio_flag = 0; pCodecCtx = p_para->pFormatCtx->streams[p_para->astream_info.audio_index]->codec; /*if ((codec->audio_type == AFORMAT_ADPCM) || (codec->audio_type == AFORMAT_WMA) || (codec->audio_type == AFORMAT_WMAPRO) || (codec->audio_type == AFORMAT_PCM_S16BE) || (codec->audio_type == AFORMAT_PCM_S16LE) || (codec->audio_type == AFORMAT_PCM_U8) || (codec->audio_type == AFORMAT_PCM_BLURAY)||(codec->audio_type == AFORMAT_AMR)) {*/ if (IS_AUIDO_NEED_EXT_INFO(codec->audio_type)) { codec->audio_info.bitrate = pCodecCtx->sample_fmt; codec->audio_info.sample_rate = pCodecCtx->sample_rate; codec->audio_info.channels = pCodecCtx->channels; codec->audio_info.codec_id = pCodecCtx->codec_id; codec->audio_info.block_align = pCodecCtx->block_align; codec->audio_info.extradata_size = pCodecCtx->extradata_size; if (codec->audio_info.extradata_size > 0) { if (codec->audio_info.extradata_size > AUDIO_EXTRA_DATA_SIZE) { log_print("[%s:%d],extra data size exceed max extra data buffer,cut it to max buffer size ", __FUNCTION__, __LINE__); codec->audio_info.extradata_size = AUDIO_EXTRA_DATA_SIZE; } memcpy((char*)codec->audio_info.extradata, pCodecCtx->extradata, codec->audio_info.extradata_size); } codec->audio_info.valid = 1; } if(IS_AUDIO_NOT_SUPPORTED_BY_AUDIODSP(codec->audio_type,pCodecCtx)){ codec->dspdec_not_supported = 1; log_print("main profile aac not supported by dsp decoder,so set dspdec_not_supported flag\n"); } codec->avsync_threshold = p_para->start_param->avsync_threshold; log_print("[%s:%d]audio bitrate=%d sample_rate=%d channels=%d codec_id=%x block_align=%d,extra size\n", __FUNCTION__, __LINE__, codec->audio_info.bitrate, codec->audio_info.sample_rate, codec->audio_info.channels, codec->audio_info.codec_id, codec->audio_info.block_align, codec->audio_info.extradata_size); } if (sinfo->has_sub) { codec->has_sub = 1; codec->sub_pid = sinfo->sub_pid; codec->sub_type = sinfo->sub_type; } codec->stream_type = stream_type_convert(p_para->stream_type, codec->has_video, codec->has_audio); codec->packet_size = p_para->pFormatCtx->orig_packet_size; ret = codec_init(codec); if (ret != CODEC_ERROR_NONE) { if (ret != CODEC_OPEN_HANDLE_FAILED) { codec_close(codec); } goto error1; } p_para->codec = codec; return PLAYER_SUCCESS; error1: log_print("[ts]codec_init failed!\n"); codec_free(codec); return DECODER_INIT_FAILED; }
int nodeup_postmove(int argc, char *argv[]) { FILE *f; char line[200]; int i, j; long long values[3] = { 0, 0, 0 }; static char *files[] = { PROC_TMP "/cpuinfo", PROC_TMP "/meminfo", 0 }; struct info_t { char *fmt; long long *value; long long scale; } info[] = { #if defined(__alpha__) { "cpus active : %Ld", &values[0], 1}, { "cycle frequency [Hz] : %Ld", &values[1], 1}, #endif #if defined(__i386__) || defined(__x86_64__) { "cpu MHz : %Ld", &values[1], 1000000}, { "processor\t:", &values[0], 0}, #endif #if defined(__powerpc64__) || defined(powerpc) { "clock\t\t: %Ld", &values[1], 1000000}, { "processor\t:", &values[0], 0}, #endif { "MemTotal: %Ld", &values[2], 1024}, { 0} }; if (nodeup_mnt_proc(PROC_TMP)) return -1; for (i = 0; files[i]; i++) { if (!(f = fopen(files[i], "r"))) { perror(files[i]); exit(1); } while (fgets(line, 100, f)) { for (j = 0; info[j].fmt; j++) { if (info[j].scale && sscanf(line, info[j].fmt, info[j].value) == 1) { (*info[j].value) *= info[j].scale; break; } if (!info[j].scale && strncmp(info[j].fmt, line, strlen(info[j].fmt)) == 0) { (*info[j].value)++; break; } } } fclose(f); } log_print(LOG_INFO, "cpus=%Ld; hz=%Ld; mem=%Ld\n", values[0], values[1], values[2]); nodeup_rpc(store_info_callback, values, sizeof(values), 0, 0); return 0; }
void set_time(unsigned char loctype, unsigned char invtype, unsigned char invno, time_t tWhen ) { int index; index = -1; switch(loctype) { case LOCTYPE_PHSC: switch(invtype) { case INVTYPE_LINK: index = IDX_LINK + invno; break; case INVTYPE_POWER: index = IDX_PWR + invno; break; case INVTYPE_FAN: index = IDX_FAN + invno; break; case INVTYPE_DISKARRAY: index = IDX_DISKAR + invno; break; case INVTYPE_PORT: index = IDX_PORT + invno; } break; case LOCTYPE_PROCESS: switch(invtype) { case INVTYPE_USERPROC: index = 0; } case LOCTYPE_LOAD: switch(invtype) { case INVTYPE_CPU: index = IDX_CPU; break; case INVTYPE_MEMORY: index = IDX_MEM; break; case INVTYPE_DISK: index = IDX_DISK+invno; break; case INVTYPE_QUEUE: index = IDX_QUE; break; case INVTYPE_NIFO: index = IDX_NIFO; break; } break; } if(index < 0) { log_print(LOGN_WARN,"UNVALID REFERENCE : LOCTYPE[%d] INVTYPE[%d] INVNO[%d] TIME[%ld]", loctype, invtype, invno, tWhen ); return; } else if(index == 0) { log_print(LOGN_INFO,"INVOKED PROCESS IDX[%d]",invno); return; } fidb->tEventUpTime[index] = tWhen; log_print(LOGN_INFO, "STORED EVENTTIME[%ld] INDEX[%d]", tWhen, index); }