/********************** *** Initialization *** **********************/ int main(int argc, char** argv) { gboolean daemon_mode = TRUE; const char* username; const char* password; GMainLoop* main_loop; /* Parse command line options */ int opt; while ((opt = getopt(argc, argv, "dfhv")) != -1) { switch (opt) { case 'd': debug_mode = TRUE; case 'v': verbose_mode = TRUE; case 'f': daemon_mode = FALSE; break; default: printf("Usage: spopd [options]\n" "Options:\n" " -d debug mode (implies -f and -v)\n" " -f run in foreground (default: fork to background)\n" " -v verbose mode (implies -f)\n" " -h display this message\n"); return 0; } } g_set_application_name("spop " SPOP_VERSION); g_set_prgname("spop"); g_type_init(); printf("%s\n", copyright_notice); /* Log handler */ logging_init(); if (!daemon_mode) { /* Stay in foreground: do everything here */ if (debug_mode) g_info("Running in debug mode"); } else { /* Run in daemon mode: fork to background */ printf("Switching to daemon mode...\n"); if (daemon(0, 0) != 0) g_error("Error while forking process: %s", g_strerror(errno)); } /* Init essential stuff */ main_loop = g_main_loop_new(NULL, FALSE); exit_handler_init(); /* Read username and password */ username = config_get_string("spotify_username"); password = config_get_string("spotify_password"); /* Init plugins */ plugins_init(); /* Init login */ session_init(); session_login(username, password); /* Init various subsystems */ interface_init(); /* Event loop */ g_main_loop_run(main_loop); return 0; }
/** * Set the page cache size. * @return 0 if OK, -1 on failure with errno set. */ int setcache(DBM *db, long pages) { struct lru_cache *cache = db->cache; gboolean wdelay; if (pages <= 0) { errno = EINVAL; return -1; } if (NULL == cache) return init_cache(db, pages, FALSE); /* * Easiest case: the size identical. */ if (pages == cache->pages) return 0; /* * Cache size is changed. * * This means the arena will be reallocated, so we must invalidate the * current db->pagbuf pointer, which lies within the old arena. It is * sufficient to reset db->pagbno, forcing a reload from the upper layers. * Note than when the cache size is enlarged, the old page is still cached * so reloading will be just a matter of recomputing db->pagbuf. We could * do so here, but cache size changes should only be infrequent. * * We also reset all the cache statistics, since a different cache size * will imply a different set of hit/miss ratio. */ db->pagbno = -1; /* Current page address will become invalid */ db->pagbuf = NULL; if (common_stats) { g_info("sdbm: \"%s\" LRU cache size %s from %ld page%s to %ld", sdbm_name(db), pages > cache->pages ? "increased" : "decreased", cache->pages, 1 == cache->pages ? "" : "s", pages); log_lrustats(db); } cache->rhits = cache->rmisses = 0; cache->whits = cache->wmisses = 0; /* * Straightforward: the size is increased. */ if (pages > cache->pages) { char *new_arena = vmm_alloc(pages * DBM_PBLKSIZ); if (NULL == new_arena) return -1; memmove(new_arena, cache->arena, cache->pages * DBM_PBLKSIZ); vmm_free(cache->arena, cache->pages * DBM_PBLKSIZ); cache->arena = new_arena; cache->dirty = wrealloc(cache->dirty, cache->pages, pages); cache->numpag = wrealloc(cache->numpag, cache->pages * sizeof(long), pages * sizeof(long)); cache->pages = pages; return 0; } /* * Difficult: the size is decreased. * * The current page buffer could point in a cache area that is going * to disappear, and the internal data structures must forget about * all the old indices that are greater than the new limit. * * We do not try to optimize anything here, as this call should happen * only infrequently: we flush the current cache (in case there are * deferred writes), destroy the LRU cache data structures, recreate a * new one and invalidate the current DB page. */ wdelay = cache->write_deferred; flush_dirtypag(db); free_cache(cache); return setup_cache(cache, pages, wdelay); }
JsonObject * cockpit_auth_login_finish (CockpitAuth *self, GAsyncResult *result, CockpitAuthFlags flags, GHashTable *out_headers, GError **error) { CockpitAuthClass *klass = COCKPIT_AUTH_GET_CLASS (self); CockpitAuthenticated *authenticated; CockpitTransport *transport = NULL; JsonObject *prompt_data = NULL; CockpitCreds *creds; gchar *cookie_b64 = NULL; gchar *cookie_name = NULL; gchar *header; gchar *id; g_return_val_if_fail (klass->login_finish != NULL, FALSE); creds = klass->login_finish (self, result, out_headers, &prompt_data, &transport, error); self->startups--; if (creds == NULL) return prompt_data; id = cockpit_auth_nonce (self); authenticated = g_new0 (CockpitAuthenticated, 1); authenticated->cookie = g_strdup_printf ("v=2;k=%s", id); authenticated->creds = creds; authenticated->service = cockpit_web_service_new (creds, transport); authenticated->auth = self; authenticated->idling_sig = g_signal_connect (authenticated->service, "idling", G_CALLBACK (on_web_service_idling), authenticated); authenticated->destroy_sig = g_signal_connect (authenticated->service, "destroy", G_CALLBACK (on_web_service_destroy), authenticated); if (transport) g_object_unref (transport); g_object_weak_ref (G_OBJECT (authenticated->service), on_web_service_gone, authenticated); /* Start off in the idling state, and begin a timeout during which caller must do something else */ on_web_service_idling (authenticated->service, authenticated); g_hash_table_insert (self->authenticated, authenticated->cookie, authenticated); g_debug ("sending %s credential id '%s' for user '%s'", id, cockpit_creds_get_application (creds), cockpit_creds_get_user (creds)); g_free (id); if (out_headers) { gboolean force_secure = !(flags & COCKPIT_AUTH_COOKIE_INSECURE); cookie_name = application_cookie_name (cockpit_creds_get_application (creds)); cookie_b64 = g_base64_encode ((guint8 *)authenticated->cookie, strlen (authenticated->cookie)); header = g_strdup_printf ("%s=%s; Path=/; %s HttpOnly", cookie_name, cookie_b64, force_secure ? " Secure;" : ""); g_free (cookie_b64); g_free (cookie_name); g_hash_table_insert (out_headers, g_strdup ("Set-Cookie"), header); } g_info ("logged in user: %s", cockpit_creds_get_user (authenticated->creds)); return cockpit_creds_to_json (creds); }
static void load_input_conf(GmpvMpv *mpv, const gchar *input_conf) { const gchar *default_keybinds[] = DEFAULT_KEYBINDS; gchar *tmp_path; FILE *tmp_file; gint tmp_fd; tmp_fd = g_file_open_tmp(NULL, &tmp_path, NULL); tmp_file = fdopen(tmp_fd, "w"); mpv->tmp_input_file = tmp_path; if(!tmp_file) { g_error("Failed to open temporary input config file"); } for(gint i = 0; default_keybinds[i]; i++) { const gsize len = strlen(default_keybinds[i]); gsize write_size; gint rc; write_size = fwrite(default_keybinds[i], len, 1, tmp_file); rc = fputc('\n', tmp_file); if(write_size != 1 || rc != '\n') { g_error( "Error writing default keybindings to " "temporary input config file" ); } } g_debug("Using temporary input config file: %s", tmp_path); mpv_set_option_string(mpv->mpv_ctx, "input-conf", tmp_path); if(input_conf && strlen(input_conf) > 0) { const gsize buf_size = 65536; void *buf = g_malloc(buf_size); FILE *src_file = g_fopen(input_conf, "r"); gsize read_size = buf_size; if(!src_file) { g_warning( "Cannot open input config file: %s", input_conf ); } while(src_file && read_size == buf_size) { read_size = fread(buf, 1, buf_size, src_file); if(read_size != fwrite(buf, 1, read_size, tmp_file)) { g_error( "Error writing requested input " "config file to temporary " "input config file" ); } } g_info("Loaded input config file: %s", input_conf); g_free(buf); } fclose(tmp_file); }
static void gml_hx_common( gml_tag gtag, int hx_lvl ) { char * p; char * headp; bool idseen; bool stitleseen; int rc; int k; size_t headlen; size_t txtlen; char hnumstr[64]; ref_entry * re; ref_entry * rwk; static char hxstr[4] = ":HX"; static char htextx[8] = "$htextX"; static char headx[7] = "$headX"; gtag = gtag; *(hxstr + 2) = '0' + hx_lvl; htextx[6] = '0' + hx_lvl; hnumx[5] = '0' + hx_lvl; headx[5] = '0' + hx_lvl; switch( hx_lvl ) { case 0: if( !((ProcFlags.doc_sect == doc_sect_body) || (ProcFlags.doc_sect_nxt == doc_sect_body)) ) { g_err( err_tag_wrong_sect, hxstr, ":BODY section" ); err_count++; file_mac_info(); } break; case 1: if( !((ProcFlags.doc_sect >= doc_sect_body) || (ProcFlags.doc_sect_nxt >= doc_sect_body)) ) { g_err( err_tag_wrong_sect, hxstr, ":BODY :APPENDIX :BACKM sections" ); err_count++; file_mac_info(); } break; default: if( !((ProcFlags.doc_sect >= doc_sect_abstract) || (ProcFlags.doc_sect_nxt >= doc_sect_abstract)) ) { g_err( err_tag_wrong_sect, hxstr, ":ABSTRACT section or later" ); err_count++; file_mac_info(); } break; } if( layout_work.hx[hx_lvl].number_form != num_none ) { layout_work.hx[hx_lvl].headn++; } idseen = false; stitleseen = false; p = scan_start; re = NULL; /***********************************************************************/ /* Scan attributes for :Hx */ /* id= */ /* stitle= */ /***********************************************************************/ for( ;; ) { while( *p == ' ' ) { p++; } if( *p == '\0' || *p == '.' ) { break; // tag end found } if( !strnicmp( "stitle=", p, 7 ) ) { p += 6; stitleseen = true; /***************************************************************/ /* Although unsupported scan stitle='xxx' */ /***************************************************************/ g_warn( wng_unsupp_att, "stitle" ); wng_count++; file_mac_info(); p = get_att_value( p ); scan_start = p; if( !ProcFlags.tag_end_found ) { continue; } break; } /*******************************************************************/ /* ID='xxxxxxxx' */ /*******************************************************************/ if( !strnicmp( "id=", p, 3 ) ) { p += 2; p = get_refid_value( p ); if( val_len > 0 ) { idseen = true; // valid id attribute found *(val_start + val_len) = '\0'; if( re == NULL ) { // prepare reference entry re = mem_alloc( sizeof( ref_entry ) ); init_ref_entry( re, val_start, val_len ); } else { fill_id( re, val_start, val_len ); } } scan_start = p; if( !ProcFlags.tag_end_found ) { continue; } break; } /*******************************************************************/ /* no more valid attributes, process remaining input as header text*/ /*******************************************************************/ break; } if( *p == '.' ) { // tag end ? p++; } /************************************************************************/ /* set the global vars $headx, $headnumx, $htextx */ /* perhaps text translated to upper or lower case */ /************************************************************************/ while( *p == ' ' ) { // ignore leading blanks p++; } if( *p ) { // text exists if( layout_work.hx[hx_lvl].cases == case_lower ) { strlwr( p ); } else if( layout_work.hx[hx_lvl].cases == case_upper ) { strupr( p ); } } rc = add_symvar( &global_dict, htextx, p, no_subscript, 0 ); update_headnumx( hx_lvl, hnumstr, sizeof( hnumstr ) ); txtlen = strlen( p ); headlen = strlen( hnumstr) + txtlen + 2; headp = mem_alloc( headlen ); if( layout_work.hx[hx_lvl].number_form != num_none ) { strcpy( headp, hnumstr); // numbered header strcat( headp, " " ); } else { *headp = '\0'; } strcat( headp, p ); rc = add_symvar( &global_dict, headx, headp, no_subscript, 0 ); out_msg( " %s\n", headp ); // always verbose output ? TBD mem_free( headp ); /***********************************************************************/ /* if id specified add it to reference dict */ /***********************************************************************/ if( idseen ) { rwk = find_refid( ref_dict, re->id ); if( !rwk ) { // new entry if( txtlen > 0 ) { // text line not empty re->u.info.text_cap = mem_alloc( txtlen + 1 ); strcpy( re->u.info.text_cap, p ); } add_ref_entry( &ref_dict, re ); re = NULL; // free will be done via dictionary } else { /***************************************************************/ /* test for duplicate id */ /* it is done with comparing line no only, in the hope that */ /* two identical ids are not specified in different files on */ /* the same line no. */ /***************************************************************/ if( re->lineno != rwk->lineno ) { g_err( wng_id_xxx, re->id ); g_info( inf_id_duplicate ); file_mac_info(); err_count++; } if( re->u.info.text_cap != NULL ) { mem_free( re->u.info.text_cap ); } mem_free( re ); } } if( layout_work.hx[hx_lvl].number_reset ) { for( k = hx_lvl + 1; k < 7; k++ ) { layout_work.hx[k].headn = 0;// reset following levels if( layout_work.hx[k].headnsub != NULL ) { *(layout_work.hx[k].headnsub->value) = '\0'; } } } /***********************************************************************/ /* creation of actual heading */ /***********************************************************************/ /***********************************************************************/ /* eject page(s) if specified */ /***********************************************************************/ if( layout_work.hx[hx_lvl].page_eject != ej_no ) { if( ProcFlags.page_started ) { do_page_out(); reset_t_page(); } if( !ProcFlags.start_section ) { start_doc_sect(); } set_headx_banners( hx_lvl ); // set possible banners reset_t_page(); // and adjust page margins if( (layout_work.hx[hx_lvl].page_eject == ej_odd) && (page & 1) ) { do_page_out(); // next page would be even reset_t_page(); } else if( (layout_work.hx[hx_lvl].page_eject == ej_even) && !(page & 1) ) { do_page_out(); // next page would be odd reset_t_page(); } } if( layout_work.hx[hx_lvl].display_heading ) { hx_header( hx_lvl, hnumstr, p ); } scan_start = scan_stop; return; }
static void onNativeWindowResized(ANativeActivity* activity, ANativeWindow* window) { g_info("NativeWindowResized: %p -- %p\n", activity, window); //android_app_write_cmd((struct android_app*)activity->instance, APP_CMD_WINDOW_RESIZED); }
static void onContentRectChanged(ANativeActivity* activity, const ARect* rect) { g_info("ContentRectChanged: %p -- (%d,%d)-(%d,%d)\n", activity, rect->left, rect->top, rect->right, rect->bottom); //android_app_set_content_rect((struct android_app*)activity->instance, rect); }
static void queue_outgoing(struct mwChannel *chan, struct mwMsgChannelSend *msg) { g_info("queue_outgoing, channel 0x%08x", chan->id); chan->outgoing_queue = g_slist_append(chan->outgoing_queue, msg); }
static int execute_command(const gchar *command, const gchar *username, const gchar *password, const gchar *lttd_path) { pid_t pid; int fdpty; pid = forkpty(&fdpty, NULL, NULL, NULL); int retval = 0; if(pid > 0) { /* parent */ gchar buf[256]; int status; ssize_t count; /* discuss with su */ struct pollfd pollfd; int num_rdy; int num_hup = 0; enum read_state { GET_LINE, GET_SEMI, GET_SPACE } read_state = GET_LINE; retval = fcntl(fdpty, F_SETFL, O_WRONLY); if(retval == -1) { perror("Error in fcntl"); goto wait_child; } /* Read the output from the child terminal before the prompt. If no data in * 200 ms, we stop reading to give the password */ g_info("Reading from child console..."); while(1) { pollfd.fd = fdpty; pollfd.events = POLLIN|POLLPRI|POLLERR|POLLHUP|POLLNVAL; num_rdy = poll(&pollfd, 1, -1); if(num_rdy == -1) { perror("Poll error"); goto wait_child; } /* Timeout : Stop waiting for chars */ if(num_rdy == 0) goto wait_child; /* Check for fatal errors */ if(pollfd.revents & POLLERR) { g_warning("Error returned in polling fd\n"); num_hup++; } if(pollfd.revents & POLLNVAL) { g_warning("Polling fd tells it is not open"); num_hup++; } if(pollfd.revents & POLLHUP) { g_info("Polling FD : hung up."); num_hup++; } if(pollfd.revents & (POLLIN | POLLPRI)) { int count; count = read (fdpty, buf, 256); if(count > 0) { unsigned int i; buf[count] = '\0'; g_printf("%s", buf); for(i=0; i<count; i++) { switch(read_state) { case GET_LINE: if(buf[i] == '\n') { read_state = GET_SEMI; g_debug("Tracecontrol input line skip\n"); } break; case GET_SEMI: if(buf[i] == ':') { g_debug("Tracecontrol input : marker found\n"); read_state = GET_SPACE; } break; case GET_SPACE: if(buf[i] == ' ') { g_debug("Tracecontrol input space marker found\n"); goto write_password; } break; } } } else if(count == -1) { perror("Error in read"); goto wait_child; } } if(num_hup > 0) { g_warning("Child hung up without returning a full reply"); goto wait_child; } } write_password: fsync(fdpty); pollfd.fd = fdpty; pollfd.events = POLLOUT|POLLERR|POLLHUP|POLLNVAL; num_rdy = poll(&pollfd, 1, -1); if(num_rdy == -1) { perror("Poll error"); goto wait_child; } /* Write the password */ g_info("Got su prompt, now writing password..."); int ret; sleep(1); ret = write(fdpty, password, strlen(password)); if(ret < 0) perror("Error in write"); ret = write(fdpty, "\n", 1); if(ret < 0) perror("Error in write"); fsync(fdpty); /* Take the output from the terminal and show it on the real console */ g_info("Getting data from child terminal..."); while(1) { int num_hup = 0; pollfd.fd = fdpty; pollfd.events = POLLIN|POLLPRI|POLLERR|POLLHUP|POLLNVAL; num_rdy = poll(&pollfd, 1, -1); if(num_rdy == -1) { perror("Poll error"); goto wait_child; } if(num_rdy == 0) break; if(pollfd.revents & (POLLERR|POLLNVAL)) { g_warning("Error returned in polling fd\n"); num_hup++; } if(pollfd.revents & (POLLIN|POLLPRI) ) { count = read (fdpty, buf, 256); if(count > 0) { buf[count] = '\0'; printf("%s", buf); } else if(count == -1) { perror("Error in read"); goto wait_child; } } if(pollfd.revents & POLLHUP) { g_info("Polling FD : hung up."); num_hup++; } if(num_hup > 0) goto wait_child; } wait_child: g_info("Waiting for child exit..."); ret = waitpid(pid, &status, 0); if(ret == -1) { g_warning("An error occured in wait : %s", strerror(errno)); } else { if(WIFEXITED(status)) if(WEXITSTATUS(status) != 0) { retval = WEXITSTATUS(status); g_warning("An error occured in the su command : %s", strerror(retval)); } } g_info("Child exited."); } else if(pid == 0) { /* Setup environment variables */ if(strcmp(lttd_path, "") != 0) setenv("LTT_DAEMON", lttd_path, 1); /* One comment line (must be only one) */ g_printf("Executing (as %s) : %s\n", username, command); execlp("su", "su", "-p", "-c", command, username, NULL); exit(-1); /* not supposed to happen! */ //gint ret = execvp(); } else { /* error */ g_warning("Error happened when forking for su"); } return retval; }
/* Check for completed transfers, and remove their easy handles */ static void check_run_count(void) { g_debug("%s queued %i active %i", __PRETTY_FUNCTION__, curl_runtime.queued, curl_runtime.active); if( curl_runtime.queued > curl_runtime.active ) { char *eff_url=NULL; CURLMsg *msg; int msgs_left; struct session *session=NULL; CURL*easy; g_debug("REMAINING: %d", curl_runtime.queued); easy=NULL; while( (msg = curl_multi_info_read(curl_runtime.multi, &msgs_left)) ) { if( msg->msg == CURLMSG_DONE ) { curl_runtime.queued--; easy=msg->easy_handle; curl_easy_getinfo(easy, CURLINFO_PRIVATE, (char **)&session ); curl_easy_getinfo(easy, CURLINFO_EFFECTIVE_URL, &eff_url); switch( session->type ) { case session_type_download: if( msg->data.result == CURLE_OK ) { g_info("DOWNLOAD DONE: %s => (%d) %s", eff_url, msg->data.result, session->error); tempfile_close(session->action.download.file); struct incident *i = incident_new("dionaea.download.complete"); incident_value_string_set(i, "path", g_string_new(session->action.download.file->path)); incident_value_string_set(i, "url", g_string_new(session->url)); if( session->action.download.ctxcon ) incident_value_con_set(i, "con", session->action.download.ctxcon); incident_report(i); incident_free(i); } else { g_warning("DOWNLOAD FAIL: %s => (%d) %s", eff_url, msg->data.result, session->error); tempfile_close(session->action.download.file); } break; case session_type_upload: if( msg->data.result == CURLE_OK ) { g_info("UPLOAD DONE: %s => (%d) %s", eff_url, msg->data.result, session->error); if( session->action.upload.callback == NULL ) break; tempfile_close(session->action.upload.file); // if we have a callback, call the callback struct incident *i = incident_new(session->action.upload.callback); incident_value_string_set(i, "path", g_string_new(session->action.upload.file->path)); if( session->action.upload.userdata != NULL ) incident_value_string_set(i, "_userdata", g_string_new(session->action.upload.userdata)); incident_report(i); incident_free(i); tempfile_unlink(session->action.upload.file); } else { g_warning("UPLOAD FAIL: %s => (%d) %s", eff_url, msg->data.result, session->error); if( session->action.upload.callback == NULL ) break; tempfile_close(session->action.upload.file); tempfile_unlink(session->action.upload.file); } break; } curl_multi_remove_handle(curl_runtime.multi, easy); curl_easy_cleanup(easy); session_free(session); } } } }
static bool curl_new(struct dionaea *d) { g_debug("%s", __PRETTY_FUNCTION__); struct lcfgx_tree_node *node; if( lcfgx_get_string(g_dionaea->config.root, &node, "downloads.dir") != LCFGX_PATH_FOUND_TYPE_OK ) { g_warning("missing downloads.dir in dionaea.conf"); return false; } curl_runtime.download_dir = g_strdup((char *)node->value.string.data); if( curl_global_init(CURL_GLOBAL_ALL) != 0 ) return false; curl_version_info_data *curlinfo; curlinfo = curl_version_info(CURLVERSION_NOW); GString *features = g_string_new(""); GString *protocols = g_string_new(""); if( curlinfo->features ) { struct curl_feature { const char *name; int bitmask; }; static const struct curl_feature feats[] = { {"c-ares", CURL_VERSION_ASYNCHDNS}, {"debug", CURL_VERSION_DEBUG}, #ifdef CURL_VERSION_CURLDEBUG {"debugmemory", CURL_VERSION_CURLDEBUG}, #endif {"gss", CURL_VERSION_GSSNEGOTIATE}, {"idn", CURL_VERSION_IDN}, {"ipv6", CURL_VERSION_IPV6}, {"largefile", CURL_VERSION_LARGEFILE}, {"ntlm", CURL_VERSION_NTLM}, {"spnego", CURL_VERSION_SPNEGO}, {"ssl", CURL_VERSION_SSL}, {"sspi", CURL_VERSION_SSPI}, {"krb4", CURL_VERSION_KERBEROS4}, {"libz", CURL_VERSION_LIBZ}, {"charconv", CURL_VERSION_CONV} }; for( unsigned int i=0; i<sizeof(feats)/sizeof(feats[0]); i++ ) if( curlinfo->features & feats[i].bitmask ) g_string_append_printf(features, ",%s", feats[i].name); } if( curlinfo->protocols ) for( const char * const *proto=curlinfo->protocols; *proto; ++proto ) g_string_append_printf(protocols, ",%s", *proto); g_info("curl version %s features:%s protocols:%s ", curlinfo->version, features->str+1, protocols->str+1); g_string_free(features, TRUE); g_string_free(protocols, TRUE); curl_runtime.multi = curl_multi_init(); ev_timer_init(&curl_runtime.timer_event, timer_cb, 0., 0.); curl_multi_setopt(curl_runtime.multi, CURLMOPT_SOCKETFUNCTION, curl_socketfunction_cb); curl_multi_setopt(curl_runtime.multi, CURLMOPT_SOCKETDATA, NULL); curl_multi_setopt(curl_runtime.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb); curl_multi_setopt(curl_runtime.multi, CURLMOPT_TIMERDATA, NULL); CURLMcode rc; do { rc = curl_multi_socket_all(curl_runtime.multi, &curl_runtime.active); } while( CURLM_CALL_MULTI_PERFORM == rc ); curl_runtime.download_ihandler = ihandler_new("dionaea.download.offer", curl_ihandler_cb, NULL); curl_runtime.upload_ihandler = ihandler_new("dionaea.upload.request", curl_ihandler_cb, NULL); return true; }
static gboolean handle_kill_sessions (CockpitAccount *object, GDBusMethodInvocation *invocation) { Account *acc = ACCOUNT (object); GError *error = NULL; if (!auth_check_sender_role (invocation, COCKPIT_ROLE_USER_ADMIN)) return TRUE; if (acc->u) { gs_unref_object GDBusConnection *bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error); if (bus == NULL) goto out; GVariant *result = g_dbus_connection_call_sync (bus, "org.freedesktop.login1", "/org/freedesktop/login1", "org.freedesktop.login1.Manager", "KillUser", g_variant_new ("(ui)", act_user_get_uid (acc->u), SIGTERM), NULL, 0, -1, NULL, &error); if (!error) { g_variant_unref (result); } else { /* logind from systemd 208 is buggy, so we use systemd directly if it fails https://bugs.freedesktop.org/show_bug.cgi?id=71092 */ g_dbus_error_strip_remote_error (error); g_warning ("logind.KillUser failed (%s), trying systemd.KillUnit", error->message); g_clear_error (&error); gs_free gchar *unit = g_strdup_printf ("user-%d.slice", act_user_get_uid (acc->u)); GVariant *result = g_dbus_connection_call_sync (bus, "org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "KillUnit", g_variant_new ("(ssi)", unit, "all", SIGTERM), NULL, 0, -1, NULL, &error); if (!error) { g_info ("systemd.KillUnit worked"); g_variant_unref (result); } } } out: if (error) { g_dbus_method_invocation_return_error (invocation, COCKPIT_ERROR, COCKPIT_ERROR_FAILED, "Failed to kill sessions: %s", error->message); g_error_free (error); } else cockpit_account_complete_kill_sessions (object, invocation); return TRUE; }
void scr_do( void ) { ifcb * cb = input_cbs->if_cb; condcode cc; char linestr[MAX_L_AS_STR]; scan_err = false; garginit(); // find end of control word cc = getarg(); cb->if_flags[cb->if_level].ifcwdo = false; if( cc == omit || !strnicmp( tok_start, "begin", 5 )) { if( !(cb->if_flags[cb->if_level].ifthen || cb->if_flags[cb->if_level].ifelse) || cb->if_flags[cb->if_level].ifdo ) { scan_err = true; g_err( err_if_do ); if( input_cbs->fmflags & II_macro ) { ultoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { ultoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } show_ifcb( "dobegin", cb ); show_include_stack(); err_count++; return; } cb->if_flags[cb->if_level].ifdo = true; if( input_cbs->fmflags & II_research && GlobalFlags.firstpass ) { show_ifcb( "dobegin", cb ); } scan_restart = scan_stop + 1; return; } else { if( !strnicmp( tok_start, "end", 3 )) { if( input_cbs->fmflags & II_research && GlobalFlags.firstpass ) { show_ifcb( "doend", cb ); } do { // loop for last active .do begin if( cb->if_flags[cb->if_level].ifdo ) { cb->if_flags[cb->if_level].ifdo = false; if( input_cbs->fmflags & II_research && GlobalFlags.firstpass ) { show_ifcb( "doend", cb ); } scan_restart = scan_stop + 1; return; } if( cb->if_flags[cb->if_level].ifthen || cb->if_flags[cb->if_level].ifelse || !(cb->if_flags[cb->if_level].iftrue || cb->if_flags[cb->if_level].iffalse) ) { scan_err = true; g_err( err_if_do_end ); if( input_cbs->fmflags & II_macro ) { ultoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { ultoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } show_ifcb( "doend", cb ); show_include_stack(); err_count++; return; } } while( cb->if_level-- > 0 ); #if 0 if( input_cbs->fmflags & II_research && GlobalFlags.firstpass ) { out_msg( "\t.do end Level %d\n" "\t.ifcb iftrue %d, iffalse %d\n", cb->if_level, cb->if_flags[cb->if_level].iftrue, cb->if_flags[cb->if_level].iffalse ); } #endif } else { scan_err = true; g_err( err_if_do_fun ); if( input_cbs->fmflags & II_macro ) { ultoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { ultoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } show_include_stack(); err_count++; return; } } if( input_cbs->fmflags & II_research && GlobalFlags.firstpass ) { show_ifcb( "do xx", cb ); } scan_restart = scan_stop + 1; return; }
void scr_if( void ) { ifcb * cb; // if stack ptr condcode cct1; condcode cct2; condcode ccrelop; termcb t1; // first argument termcb t2; // second argument relop relation; // the relation between t1 and t2 logop logical; // if more than 1 condition bool ifcond; // current condition bool totalcondition; // resultant condition bool firstcondition; // first comparison .if char linestr[MAX_L_AS_STR]; scan_err = false; firstcondition = true; // first 2 terms to compare garginit(); // find end of control word cb = input_cbs->if_cb; // get .if control block cb->if_flags[cb->if_level].ifcwif = false; // reset cwif switch for( ;; ) { // evaluate if conditions cct1 = gargterm( &t1 ); // get term 1 ccrelop = gargrelop( &relation ); // get relation operator cct2 = gargterm( &t2 ); // get term 2 if( (cct1 == no) || (cct2 == no) ) { scan_err = true; err_count++; g_err( err_if_term ); if( input_cbs->fmflags & II_macro ) { ultoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { ultoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } show_include_stack(); return; } if( ccrelop != pos ) { scan_err = true; err_count++; g_err( err_if_relop ); if( input_cbs->fmflags & II_macro ) { ultoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { ultoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } show_include_stack(); return; } // terms and operator ok now compare ifcond = ifcompare( &t1, relation, &t2 ); mem_free( t1.term_string ); // don't need the strings anymore mem_free( t2.term_string ); if( firstcondition ) { firstcondition = false; if( cb->if_level < MAX_IF_LEVEL ) { cb->if_level++; memset( &cb->if_flags[cb->if_level], '\0', sizeof( cb->if_flags[cb->if_level] ) ); cb->if_flags[cb->if_level].iflast = true; cb->if_flags[cb->if_level].ifcwte = false; // no .th .el yet cb->if_flags[cb->if_level].iftrue = false; // cond not yet true cb->if_flags[cb->if_level].iffalse = false; // cond not yet false } else { scan_err = true; g_err( err_if_nesting ); if( input_cbs->fmflags & II_macro ) { ultoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { ultoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } show_include_stack(); err_count++; return; } totalcondition = ifcond; } else { // resultant condition if( logical == AND ) { totalcondition &= ifcond; } else { totalcondition |= ifcond; } } if( totalcondition ) { // set if true / false flags cb->if_flags[cb->if_level].iftrue = true; cb->if_flags[cb->if_level].iffalse = false; } else { cb->if_flags[cb->if_level].iffalse = true; cb->if_flags[cb->if_level].iftrue = false; } while( *scan_start == ' ' ) { scan_start++; } /* * test logical condition if not line end * .if a = b or c GT d * ^^ */ if( *scan_start ) { if( *scan_start == SCR_char ) { break; // .xx can't be logical operator } if( *(scan_start + 1) == ' ' ) {// single char + blank if( *scan_start == '&' ) { logical = AND; scan_start += 2; continue; // do next conditions } else if( *scan_start == '|' ) { logical = OR; scan_start += 2; continue; // do next conditions } } else { if( !strnicmp( scan_start, "and ", 4 ) ) { logical = AND; scan_start += 4; continue; // do next conditions } else if( !strnicmp( scan_start, "or ", 3 ) ) { logical = OR; scan_start += 3; continue; // do next conditions } } } break; // no more operators / conditions } if( cb->if_level > 1 ) { // nested if if( cb->if_flags[cb->if_level - 1].ifthen ) { // object of .th if( cb->if_flags[cb->if_level - 1].iffalse ) {// last .if false cb->if_flags[cb->if_level].iftrue = true;// process nothing cb->if_flags[cb->if_level].iffalse = true; } } else { if( cb->if_flags[cb->if_level - 1].ifelse // object of .el && cb->if_flags[cb->if_level - 1].iftrue ) {// last .if true cb->if_flags[cb->if_level].iftrue = true;// process nothing cb->if_flags[cb->if_level].iffalse = true; } } } if( input_cbs->fmflags & II_research && GlobalFlags.firstpass ) { show_ifcb( "if", cb ); #if 0 out_msg( "\t.if is %s Level %d\n" "\t.ifcb iftrue %d, iffalse %d\n", totalcondition ? "true " : "false", cb->if_level, cb->if_flags[cb->if_level].iftrue, cb->if_flags[cb->if_level].iffalse ); #endif } if( *scan_start ) { // rest of line is not empty split_input( buff2, scan_start, false ); // split and process next } scan_restart = scan_stop + 1; return; }
gboolean ToolsCore_LoadPlugins(ToolsServiceState *state) { gboolean pluginDirExists; gboolean ret = FALSE; gchar *pluginRoot; guint i; GPtrArray *plugins = NULL; #if defined(sun) && defined(__x86_64__) const char *subdir = "/amd64"; #else const char *subdir = ""; #endif #if defined(OPEN_VM_TOOLS) pluginRoot = g_strdup(VMTOOLSD_PLUGIN_ROOT); #else char *instPath = GuestApp_GetInstallPath(); pluginRoot = g_strdup_printf("%s%cplugins", instPath, DIRSEPC); vm_free(instPath); #endif ASSERT(g_module_supported()); #ifdef USE_APPLOADER { Bool ret = FALSE; GModule *mainModule = g_module_open(NULL, G_MODULE_BIND_LAZY); ASSERT(mainModule); ret = g_module_symbol(mainModule, "AppLoader_LoadLibraryDependencies", (gpointer *)&LoadDependencies); g_module_close(mainModule); if (!ret) { g_critical("Unable to locate library dependency loading function.\n"); goto exit; } } #endif plugins = g_ptr_array_new(); /* * First, load plugins from the common directory. The common directory * is not required to exist unless provided on the command line. */ if (state->commonPath == NULL) { state->commonPath = g_strdup_printf("%s%s%c%s", pluginRoot, subdir, DIRSEPC, TOOLSCORE_COMMON); } else if (!g_file_test(state->commonPath, G_FILE_TEST_IS_DIR)) { g_warning("Common plugin path is not a directory: %s\n", state->commonPath); goto exit; } if (g_file_test(state->commonPath, G_FILE_TEST_IS_DIR) && !ToolsCoreLoadDirectory(&state->ctx, state->commonPath, plugins)) { goto exit; } /* * Load the container-specific plugins. Ignore if the plugin directory * doesn't exist when running in debug mode. */ if (state->pluginPath == NULL) { state->pluginPath = g_strdup_printf("%s%s%c%s", pluginRoot, subdir, DIRSEPC, state->name); } pluginDirExists = g_file_test(state->pluginPath, G_FILE_TEST_IS_DIR); if (state->debugPlugin == NULL && !pluginDirExists) { g_warning("Plugin path is not a directory: %s\n", state->pluginPath); goto exit; } if (pluginDirExists && !ToolsCoreLoadDirectory(&state->ctx, state->pluginPath, plugins)) { goto exit; } /* * All plugins are loaded, now initialize them. */ state->plugins = g_ptr_array_new(); for (i = 0; i < plugins->len; i++) { ToolsPlugin *plugin = g_ptr_array_index(plugins, i); plugin->data = plugin->onload(&state->ctx); if (plugin->data == NULL) { g_info("Plugin '%s' didn't provide deployment data, unloading.\n", plugin->fileName); ToolsCoreFreePlugin(plugin); } else if (state->ctx.errorCode != 0) { /* Break early if a plugin has requested the container to quit. */ ToolsCoreFreePlugin(plugin); break; } else { ASSERT(plugin->data->name != NULL); g_module_make_resident(plugin->module); g_ptr_array_add(state->plugins, plugin); VMTools_BindTextDomain(plugin->data->name, NULL, NULL); g_message("Plugin '%s' initialized.\n", plugin->data->name); } } /* * If there is a debug plugin, see if it exports standard plugin registration * data too. */ if (state->debugData != NULL && state->debugData->debugPlugin->plugin != NULL) { ToolsPluginData *data = state->debugData->debugPlugin->plugin; ToolsPlugin *plugin = g_malloc(sizeof *plugin); plugin->fileName = NULL; plugin->module = NULL; plugin->data = data; VMTools_BindTextDomain(data->name, NULL, NULL); g_ptr_array_add(state->plugins, plugin); } ret = TRUE; exit: if (plugins != NULL) { g_ptr_array_free(plugins, TRUE); } g_free(pluginRoot); return ret; }
static gboolean ToolsCoreLoadDirectory(ToolsAppCtx *ctx, const gchar *pluginPath, GPtrArray *regs) { gboolean ret = FALSE; const gchar *staticEntry; guint i; GDir *dir = NULL; GError *err = NULL; GPtrArray *plugins; dir = g_dir_open(pluginPath, 0, &err); if (dir == NULL) { g_warning("Error opening dir: %s\n", err->message); goto exit; } plugins = g_ptr_array_new(); /* * Load plugins in alphabetical order, so the load order is the same * regardless of how the filesystem returns entries. */ while ((staticEntry = g_dir_read_name(dir)) != NULL) { if (g_str_has_suffix(staticEntry, "." G_MODULE_SUFFIX)) { g_ptr_array_add(plugins, g_strdup(staticEntry)); } } g_dir_close(dir); g_ptr_array_sort(plugins, ToolsCoreStrPtrCompare); for (i = 0; i < plugins->len; i++) { gchar *entry; gchar *path; GModule *module = NULL; ToolsPlugin *plugin = NULL; ToolsPluginOnLoad onload; entry = g_ptr_array_index(plugins, i); path = g_strdup_printf("%s%c%s", pluginPath, DIRSEPC, entry); if (!g_file_test(path, G_FILE_TEST_IS_REGULAR)) { g_warning("File '%s' is not a regular file, skipping.\n", entry); goto next; } #ifdef USE_APPLOADER /* Trying loading the plugins with system libraries */ if (!LoadDependencies(path, FALSE)) { g_warning("Loading of library dependencies for %s failed.\n", entry); goto next; } #endif module = g_module_open(path, G_MODULE_BIND_LOCAL); #ifdef USE_APPLOADER if (module == NULL) { g_info("Opening plugin '%s' with system libraries failed: %s\n", entry, g_module_error()); /* Falling back to the shipped libraries */ if (!LoadDependencies(path, TRUE)) { g_warning("Loading of shipped library dependencies for %s failed.\n", entry); goto next; } module = g_module_open(path, G_MODULE_BIND_LOCAL); } #endif if (module == NULL) { g_warning("Opening plugin '%s' failed: %s.\n", entry, g_module_error()); goto next; } if (!g_module_symbol(module, "ToolsOnLoad", (gpointer *) &onload)) { g_warning("Lookup of plugin entry point for '%s' failed.\n", entry); goto next; } plugin = g_malloc(sizeof *plugin); plugin->fileName = entry; plugin->data = NULL; plugin->module = module; plugin->onload = onload; g_ptr_array_add(regs, plugin); next: g_free(path); if (plugin == NULL && module != NULL) { if (!g_module_close(module)) { g_warning("Error unloading plugin '%s': %s\n", entry, g_module_error()); } } } g_ptr_array_free(plugins, TRUE); ret = TRUE; exit: return ret; }
static void onLowMemory(ANativeActivity* activity) { struct android_app* android_app = (struct android_app*)activity->instance; g_info("LowMemory: %p\n", activity); //android_app_write_cmd(android_app, APP_CMD_LOW_MEMORY); }
void histo_destroy_walk(gpointer data, gpointer user_data) { g_info("Walk destroy GUI Histogram Control Flow Viewer"); guihistocontrolflow_destructor_full((HistoControlFlowData*)data); }
static void onNativeWindowRedrawNeeded(ANativeActivity* activity, ANativeWindow* window) { g_info("NativeWindowRedrawNeeded: %p -- %p\n", activity, window); //android_app_wait_redraw((struct android_app*)activity->instance); }
G_GNUC_COLD void map_test(void) { sha1_t *keys; map_t *mh, *mp; int i; size_t count; int tests; struct { unsigned insertion, contains, removal; } faster = { 0, 0, 0}; bool verbose = common_stats > 1; if (common_stats <= 0) return; XMALLOC_ARRAY(keys, ITEM_COUNT); for (i = 0; i < ITEM_COUNT; i++) random_bytes(keys[i].data, SHA1_RAW_SIZE); mh = map_create_hash(sha1_hash, sha1_eq); mp = map_create_patricia(KEYBITS); timeit(test_map_insert, mh, keys, ITEM_COUNT, LOOPS, "map hash insertion", verbose); timeit(test_map_insert, mp, keys, ITEM_COUNT, LOOPS, "map PATRICIA insertion", verbose); map_destroy(mh); map_destroy(mp); for (tests = 0, count = ITEM_COUNT; count > 1; count /= 10) { double htime; double ptime; tests++; mh = map_create_hash(sha1_hash, sha1_eq); mp = map_create_patricia(KEYBITS); htime = timeit(test_map_insert, mh, keys, count, 1, "map hash reloading", verbose); ptime = timeit(test_map_insert, mp, keys, count, 1, "map PATRICIA reloading", verbose); if (verbose) g_info("PATRICIA insertion %s than hash with %zu items", ptime < htime ? "faster" : "slower", count); if (ptime < htime) faster.insertion++; htime = timeit(test_map_contains, mh, keys, count, LOOPS, "map hash contains", verbose); ptime = timeit(test_map_contains, mp, keys, count, LOOPS, "map PATRICIA contains", verbose); if (verbose) g_info("PATRICIA contains %s than hash with %zu items", ptime < htime ? "faster" : "slower", count); if (ptime < htime) faster.contains++; htime = timeit(test_map_remove, mh, keys, count, 1, "map hash remove", verbose); ptime = timeit(test_map_remove, mp, keys, count, 1, "map PATRICIA remove", verbose); if (verbose) g_info("PATRICIA remove %s than hash with %zu items", ptime < htime ? "faster" : "slower", count); if (ptime < htime) faster.removal++; map_destroy(mh); map_destroy(mp); } if (faster.insertion) g_info("PATRICIA insert was faster than hash in %d out of %d tests", faster.insertion, tests); if (faster.contains) g_info( "PATRICIA contains was faster than hash in %d out of %d tests", faster.contains, tests); if (faster.removal) g_info("PATRICIA remove was faster than hash in %d out of %d tests", faster.removal, tests); XFREE_NULL(keys); }
/** * Set up pcap listener for the given interfaces and protocols. * @return a properly configured pcap_t* object for listening for the given protocols - NULL on error * @see pcap_protocols */ pcap_t* create_pcap_listener(const char * dev ///<[in] Device name to listen on , gboolean blocking ///<[in] TRUE if this is a blocking connection , unsigned listenmask ///<[in] Bit mask of protocols to listen for ///< (see @ref pcap_protocols "list of valid bits") , struct bpf_program*prog) ///<[out] Compiled PCAP program { pcap_t* pcdescr = NULL; bpf_u_int32 maskp = 0; bpf_u_int32 netp = 0; char errbuf[PCAP_ERRBUF_SIZE]; char * expr = NULL; int filterlen = 1; unsigned j; int cnt=0; int rc; const char ORWORD [] = " or "; gboolean need_promisc = FALSE; BINDDEBUG(pcap_t); // setbuf(stdout, NULL); setvbuf(stdout, NULL, _IONBF, 0); errbuf[0] = '\0'; // Search the list of valid bits so we can construct the libpcap filter // for the given set of protocols on the fly... // On this pass we just compute the amount of memory we'll need... for (j = 0, cnt = 0; j < DIMOF(filterinfo); ++j) { if (listenmask & filterinfo[j].filterbit) { ++cnt; if (cnt > 1) { filterlen += sizeof(ORWORD); } filterlen += strlen(filterinfo[j].filter); } } if (filterlen < 2) { g_warning("Constructed filter is too short - invalid mask argument."); return NULL; } if (NULL == (expr = malloc(filterlen))) { g_error("Out of memory!"); return NULL; } // Same song, different verse... // This time around, we construct the filter expr[0] = '\0'; for (j = 0, cnt = 0; j < DIMOF(filterinfo); ++j) { if (listenmask & filterinfo[j].filterbit) { ++cnt; if (cnt > 1) { g_strlcat(expr, ORWORD, filterlen); } g_strlcat(expr, filterinfo[j].filter, filterlen); } } if (pcap_lookupnet(dev, &netp, &maskp, errbuf) != 0) { // This is not a problem for non-IPv4 protocols... // It just looks up the ipv4 address - which we mostly don't care about. g_info("%s.%d: pcap_lookupnet(\"%s\") failed: [%s]" , __FUNCTION__, __LINE__, dev, errbuf); } if (NULL == (pcdescr = pcap_create(dev, errbuf))) { g_warning("pcap_create failed: [%s]", errbuf); goto oopsie; } //pcap_set_promisc(pcdescr, FALSE); for (j = 0; j < DIMOF(filterinfo); ++j) { if (listenmask & filterinfo[j].filterbit) { const char * addrstring = filterinfo[j].mcastaddr; if (addrstring && !_enable_mcast_address(addrstring, dev, TRUE)) { need_promisc = TRUE; } } } pcap_set_promisc(pcdescr, need_promisc); #ifdef HAVE_PCAP_SET_RFMON pcap_set_rfmon(pcdescr, FALSE); #endif pcap_setdirection(pcdescr, PCAP_D_IN); // Weird bug - returns -3 and doesn't show an error message... // And pcap_getnonblock also returns -3... Neither should happen AFAIK... errbuf[0] = '\0'; if ((rc = pcap_setnonblock(pcdescr, !blocking, errbuf)) < 0 && errbuf[0] != '\0') { g_warning("pcap_setnonblock(%d) failed: [%s] [rc=%d]", !blocking, errbuf, rc); g_warning("Have no idea why this happens - current blocking state is: %d." , pcap_getnonblock(pcdescr, errbuf)); } pcap_set_snaplen(pcdescr, 1500); /// @todo deal with pcap_set_timeout() call here. if (blocking) { pcap_set_timeout(pcdescr, 240*1000); }else{ pcap_set_timeout(pcdescr, 1); } //pcap_set_buffer_size(pcdescr, 1500); if (pcap_activate(pcdescr) != 0) { g_warning("pcap_activate failed: [%s]", pcap_geterr(pcdescr)); goto oopsie; } if (pcap_compile(pcdescr, prog, expr, FALSE, maskp) < 0) { g_warning("pcap_compile of [%s] failed: [%s]", expr, pcap_geterr(pcdescr)); goto oopsie; } if (pcap_setfilter(pcdescr, prog) < 0) { g_warning("pcap_setfilter on [%s] failed: [%s]", expr, pcap_geterr(pcdescr)); goto oopsie; } DEBUGMSG1("Compile of [%s] worked!", expr); g_info("Compile of [%s] worked! Returning %p", expr, pcdescr); free(expr); expr = NULL; return(pcdescr); oopsie: // Some kind of failure - free things up and return NULL g_warning("%s.%d: Could not set up PCAP on %s" , __FUNCTION__, __LINE__, dev); if (expr) { free(expr); expr = NULL; } if (pcdescr) { close_pcap_listener(pcdescr, dev, listenmask); pcdescr = NULL; } return NULL; }
condcode scr_substr( parm parms[MAX_FUN_PARMS], size_t parmcount, char * * result, int32_t ressize ) { char * pval; char * pend; condcode cc; int k; int n; int stringlen; int len; getnum_block gn; char padchar; char linestr[MAX_L_AS_STR]; if( (parmcount < 2) || (parmcount > 4) ) { return( neg ); } pval = parms[0].a; pend = parms[0].e; unquote_if_quoted( &pval, &pend ); stringlen = pend - pval + 1; // length of string padchar = ' '; // default padchar len = 0; n = 0; // default start pos gn.ignore_blanks = false; if( parmcount > 1 ) { // evalute start pos if( parms[1].e >= parms[1].a ) {// start pos specified gn.argstart = parms[1].a; gn.argstop = parms[1].e; cc = getnum( &gn ); if( (cc != pos) || (gn.result == 0) ) { if( !ProcFlags.suppress_msg ) { g_err( err_func_parm, "2 (startpos)" ); if( input_cbs->fmflags & II_macro ) { ultoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { ultoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } err_count++; show_include_stack(); } return( cc ); } n = gn.result - 1; } } if( parmcount > 2 ) { // evalute length if( parms[2].e >= parms[2].a ) {// length specified gn.argstart = parms[2].a; gn.argstop = parms[2].e; cc = getnum( &gn ); if( (cc != pos) || (gn.result == 0) ) { if( !ProcFlags.suppress_msg ) { g_err( err_func_parm, "3 (length)" ); if( input_cbs->fmflags & II_macro ) { ultoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { ultoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } err_count++; show_include_stack(); } return( cc ); } len = gn.result; } } if( parmcount > 3 ) { // isolate padchar if( parms[3].e >= parms[3].a ) { char * pa = parms[3].a; char * pe = parms[3].e; unquote_if_quoted( &pa, &pe ); padchar = *pa; } } pval += n; // position to startpos if( len == 0 ) { // no length specified len = pend - pval + 1; // take rest of string if( len < 0 ) { // if there is one len = 0; } } for( k = 0; k < len; k++ ) { if( (pval > pend) || (ressize <= 0) ) { break; } **result = *pval++; *result += 1; ressize--; } for( ; k < len; k++ ) { if( ressize <= 0 ) { break; } **result = padchar; *result += 1; ressize--; } **result = '\0'; return( pos ); }
void gmpv_mpv_initialize(GmpvMpv *mpv) { GSettings *main_settings = g_settings_new(CONFIG_ROOT); gchar *config_dir = get_config_dir_path(); gchar *mpvopt = NULL; gchar *current_vo = NULL; gchar *mpv_version = NULL; const struct { const gchar *name; const gchar *value; } options[] = { {"osd-level", "1"}, {"softvol", "yes"}, {"force-window", "yes"}, {"input-default-bindings", "yes"}, {"audio-client-name", ICON_NAME}, {"title", "${media-title}"}, {"autofit-larger", "75%"}, {"window-scale", "1"}, {"pause", "no"}, {"ytdl", "yes"}, {"osd-bar", "no"}, {"input-cursor", "no"}, {"cursor-autohide", "no"}, {"softvol-max", "100"}, {"config", "yes"}, {"screenshot-template", "gnome-mpv-shot%n"}, {"config-dir", config_dir}, {NULL, NULL} }; g_assert(mpv->mpv_ctx); for(gint i = 0; options[i].name; i++) { g_debug( "Applying default option --%s=%s", options[i].name, options[i].value ); mpv_set_option_string( mpv->mpv_ctx, options[i].name, options[i].value ); } if(g_settings_get_boolean(main_settings, "mpv-config-enable")) { gchar *mpv_conf = g_settings_get_string (main_settings, "mpv-config-file"); g_info("Loading config file: %s", mpv_conf); mpv_load_config_file(mpv->mpv_ctx, mpv_conf); g_free(mpv_conf); } if(g_settings_get_boolean(main_settings, "mpv-input-config-enable")) { gchar *input_conf = g_settings_get_string (main_settings, "mpv-input-config-file"); g_info("Loading input config file: %s", input_conf); load_input_conf(mpv, input_conf); g_free(input_conf); } else { load_input_conf(mpv, NULL); } mpvopt = g_settings_get_string(main_settings, "mpv-options"); g_debug("Applying extra mpv options: %s", mpvopt); /* Apply extra options */ if(apply_args(mpv->mpv_ctx, mpvopt) < 0) { const gchar *msg = _("Failed to apply one or more MPV options."); g_signal_emit_by_name(mpv, "mpv-error", msg); } if(mpv->force_opengl || mpv->wid <= 0) { g_info("Forcing --vo=opengl-cb"); mpv_set_option_string(mpv->mpv_ctx, "vo", "opengl-cb"); } else { g_debug( "Attaching mpv window to wid %#x", (guint)mpv->wid ); mpv_set_option(mpv->mpv_ctx, "wid", MPV_FORMAT_INT64, &mpv->wid); } mpv_observe_property(mpv->mpv_ctx, 0, "aid", MPV_FORMAT_INT64); mpv_observe_property(mpv->mpv_ctx, 0, "chapters", MPV_FORMAT_INT64); mpv_observe_property(mpv->mpv_ctx, 0, "core-idle", MPV_FORMAT_FLAG); mpv_observe_property(mpv->mpv_ctx, 0, "fullscreen", MPV_FORMAT_FLAG); mpv_observe_property(mpv->mpv_ctx, 0, "pause", MPV_FORMAT_FLAG); mpv_observe_property(mpv->mpv_ctx, 0, "length", MPV_FORMAT_DOUBLE); mpv_observe_property(mpv->mpv_ctx, 0, "media-title", MPV_FORMAT_STRING); mpv_observe_property(mpv->mpv_ctx, 0, "playlist-pos", MPV_FORMAT_INT64); mpv_observe_property(mpv->mpv_ctx, 0, "track-list", MPV_FORMAT_NODE); mpv_observe_property(mpv->mpv_ctx, 0, "volume", MPV_FORMAT_DOUBLE); mpv_set_wakeup_callback(mpv->mpv_ctx, wakeup_callback, mpv); mpv_check_error(mpv_initialize(mpv->mpv_ctx)); mpv_version = gmpv_mpv_get_property_string(mpv, "mpv-version"); current_vo = gmpv_mpv_get_property_string(mpv, "current-vo"); g_info("Using %s", mpv_version); if(current_vo && !GDK_IS_X11_DISPLAY(gdk_display_get_default())) { g_info( "The chosen vo is %s but the display is not X11; " "forcing --vo=opengl-cb and resetting", current_vo ); mpv->force_opengl = TRUE; mpv->state.paused = FALSE; gmpv_mpv_reset(mpv); } else { GSettings *win_settings; gdouble volume; win_settings = g_settings_new(CONFIG_WIN_STATE); volume = g_settings_get_double(win_settings, "volume")*100; g_debug("Setting volume to %f", volume); mpv_set_property( mpv->mpv_ctx, "volume", MPV_FORMAT_DOUBLE, &volume ); /* The vo should be opengl-cb if current_vo is NULL*/ if(!current_vo) { mpv->opengl_ctx = mpv_get_sub_api ( mpv->mpv_ctx, MPV_SUB_API_OPENGL_CB ); } gmpv_mpv_opt_handle_msg_level(mpv); gmpv_mpv_opt_handle_fs(mpv); gmpv_mpv_opt_handle_geometry(mpv); mpv->force_opengl = FALSE; mpv->state.ready = TRUE; g_signal_emit_by_name(mpv, "mpv-init"); g_clear_object(&win_settings); } g_clear_object(&main_settings); g_free(config_dir); g_free(mpvopt); mpv_free(current_vo); mpv_free(mpv_version); }
void gml_hdref( const gmltag * entry ) { char * p; char * pa; char * pe; char * idp; char quote; char c; bool idseen; bool pageseen; bool withpage; size_t len; char buf64[64]; ref_entry * re; static char undefid[] = "\"Undefined Heading\" on page XXX"; idseen = false; pageseen = false; withpage = false; p = scan_start; re = NULL; /***********************************************************************/ /* Scan attributes for :HDREF */ /* id= */ /* page= */ /***********************************************************************/ for( ;; ) { while( *p == ' ' ) { p++; } if( *p == '\0' || *p == '.' ) { break; // tag end found } if( !strnicmp( "page=", p, 5 ) ) { p += 5; while( *p == ' ' ) { p++; } pa = p; if( !strnicmp( "yes", p, 3 ) ) { pageseen = true; withpage = true; p += 3; } else { if( !strnicmp( "no", p, 2 ) ) { pageseen = true; withpage = false; p += 2; } else { g_err( err_inv_att_val ); file_mac_info(); err_count++; while( *p && (*p != '.') && (*p != ' ') ) p++; } } scan_start = p; continue; } if( !strnicmp( "refid=", p, 6 ) ) { p += 6; while( *p == ' ' ) { p++; } if( is_quote_char( *p ) ) { quote = *p; p++; } else { quote = '\0'; } pa = p; while( *p && is_id_char( *p ) ) { p++; } len = __min( ID_LEN, p - pa );// restrict length as in ghx.c if( len > 0 ) { idseen = true; // valid id attribute found pe = pa + len; c = *pe; *pe = '\0'; re = find_refid( ref_dict, strlwr( pa ) ); if( re != NULL ) { // id found in ref dict idp = mem_alloc( 4 + strlen( re->text_cap ) ); *idp = '"'; // decorate with quotes strcpy( idp + 1, re->text_cap ); strcat( idp, "\"" ); } else { if( GlobalFlags.lastpass ) { g_warn( wng_id_xxx, pa ); g_info( inf_id_unknown ); file_mac_info(); wng_count++; } } *pe = c; } if( *p && (quote == *p) ) { p++; } scan_start = p; continue; } /*******************************************************************/ /* no more valid attributes */ /*******************************************************************/ break; } if( *p == '.' ) { // tag end ? p++; } if( idseen ) { // id attribute was specified bool concatsave = ProcFlags.concat; ProcFlags.concat = true; // make process_text add to line if( re == NULL ) { // undefined refid process_text( undefid, g_curr_font_num ); } else { process_text( idp, g_curr_font_num ); if( withpage || (!pageseen && (page != re->pageno)) ) { sprintf_s( buf64, sizeof( buf64 ), "on page %d", re->pageno ); process_text( buf64, g_curr_font_num ); } mem_free( idp ); } ProcFlags.concat = concatsave; } else { g_err( err_att_missing ); // id attribute missing file_mac_info(); err_count++; } scan_start = p; return; }
void emulate_thread(gpointer data, gpointer user_data) { struct emu_emulate_ctx *ctx = user_data; struct emu_config *conf = ctx->config; struct emu *e = ctx->emu; struct emu_env *env = ctx->env; int ret; g_mutex_lock(&ctx->mutex); if( ctx->state == waiting ) ctx->state = running; if( ctx->time == NULL ) ctx->time = g_timer_new(); else g_timer_continue(ctx->time); while( ctx->state == running ) { if( (ctx->steps % (1024*1024)) == 0 ) { g_debug("steps %li", ctx->steps); if( ctx->steps > conf->limits.steps ) { g_info("shellcode took too many steps ... (%li steps)", ctx->steps); ctx->state = failed; break; } if( conf->limits.cpu > 0. ) { double elapsed = g_timer_elapsed(ctx->time, NULL); if( elapsed > conf->limits.cpu ) { g_info("shellcode took too long ... (%f seconds)", elapsed); ctx->state = failed; break; } } } ctx->steps++; struct emu_env_hook *hook = NULL; hook = emu_env_w32_eip_check(env); if( hook != NULL ) { if( hook->hook.win->fnhook == NULL ) { g_critical("unhooked call to %s", hook->hook.win->fnname); break; } else if( ctx->state == waiting ) /* for now, we stop! * had a blocking io call * callback from main will come at a given point * and requeue us to the threadpool */ goto unlock_and_return; } else { ret = emu_cpu_parse(emu_cpu_get(e)); struct emu_env_hook *hook =NULL; if( ret != -1 ) { hook = emu_env_linux_syscall_check(env); if( hook == NULL ) { ret = emu_cpu_step(emu_cpu_get(e)); } else { if( hook->hook.lin->fnhook != NULL ) { hook->hook.lin->fnhook(env, hook); if( ctx->state == waiting ) /* stop * as mentioned previously */ goto unlock_and_return; } } } if( ret == -1 ) { g_debug("cpu error %s", emu_strerror(e)); break; } } } g_timer_stop(ctx->time); if( ctx->state == failed ) g_debug("emulating shellcode failed"); g_mutex_unlock(&ctx->mutex); #ifdef DEBUG double elapsed = g_timer_elapsed(ctx->time, NULL); g_debug("shellcode took %f seconds on cpu, %li steps", elapsed, ctx->steps); #endif GAsyncQueue *aq = g_async_queue_ref(g_dionaea->threads->cmds); g_async_queue_push(aq, async_cmd_new(emulate_ctx_free, ctx)); g_async_queue_unref(aq); ev_async_send(g_dionaea->loop, &g_dionaea->threads->trigger); return; unlock_and_return: g_timer_stop(ctx->time); g_mutex_unlock(&ctx->mutex); }
condcode scr_index( parm parms[MAX_FUN_PARMS], size_t parmcount, char * * result, int32_t ressize ) { char * pneedle; char * pneedlend; char * phay; char * phayend; condcode cc; int index; int n; int hay_len; int needle_len; getnum_block gn; char * ph; char * pn; char linestr[MAX_L_AS_STR]; if( (parmcount < 2) || (parmcount > 3) ) { cc = neg; return( cc ); } phay = parms[0].a; phayend = parms[0].e; unquote_if_quoted( &phay, &phayend ); hay_len = phayend - phay + 1; // haystack length pneedle = parms[1].a; pneedlend = parms[1].e; unquote_if_quoted( &pneedle, &pneedlend ); needle_len = pneedlend - pneedle + 1; // needle length n = 0; // default start pos gn.ignore_blanks = false; if( parmcount > 2 ) { // evalute start pos if( parms[2].e >= parms[2].a ) {// start pos specified gn.argstart = parms[2].a; gn.argstop = parms[2].e; cc = getnum( &gn ); if( (cc != pos) || (gn.result == 0) ) { if( !ProcFlags.suppress_msg ) { g_err( err_func_parm, "3 (startpos)" ); if( input_cbs->fmflags & II_macro ) { utoa( input_cbs->s.m->lineno, linestr, 10 ); g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name ); } else { utoa( input_cbs->s.f->lineno, linestr, 10 ); g_info( inf_file_line, linestr, input_cbs->s.f->filename ); } err_count++; show_include_stack(); } return( cc ); } n = gn.result - 1; } } if( (hay_len <= 0) || // null string nothing to do (needle_len <= 0) || // needle null nothing to do (needle_len > hay_len) || // needle longer haystack (n + needle_len > hay_len) ) { // startpos + needlelen > haystack // ... match impossible **result = '0'; // return index zero *result += 1; **result = '\0'; return( pos ); } ph = phay + n; // startpos in haystack pn = pneedle; index = 0; for( ph = phay + n; ph <= phayend - needle_len + 1; ph++ ) { pn = pneedle; while( (*ph == *pn) && (pn <= pneedlend)) { ph++; pn++; } if( pn > pneedlend ) { index = ph - phay - needle_len + 1; // found, set index break; } } *result += sprintf( *result, "%d", index ); return( pos ); }
int main (int argc, char *argv[]) { gint ret = 1; CockpitWebServer *server = NULL; GOptionContext *context; CockpitHandlerData data; GTlsCertificate *certificate = NULL; GError *local_error = NULL; GError **error = &local_error; gchar **roots = NULL; gchar *cert_path = NULL; GMainLoop *loop; signal (SIGPIPE, SIG_IGN); g_setenv ("GSETTINGS_BACKEND", "memory", TRUE); g_setenv ("GIO_USE_PROXY_RESOLVER", "dummy", TRUE); g_setenv ("GIO_USE_VFS", "local", TRUE); /* Any interaction with a krb5 ccache should be explicit */ g_setenv ("KRB5CCNAME", "FILE:/dev/null", TRUE); g_type_init (); ssh_init (); memset (&data, 0, sizeof (data)); context = g_option_context_new (NULL); g_option_context_add_main_entries (context, cmd_entries, NULL); if (!g_option_context_parse (context, &argc, &argv, error)) { goto out; } cockpit_set_journal_logging (!isatty (2)); if (opt_no_tls) { /* no certificate */ } else { cert_path = cockpit_certificate_locate (FALSE, error); if (cert_path != NULL) certificate = cockpit_certificate_load (cert_path, error); if (certificate == NULL) goto out; g_info ("Using certificate: %s", cert_path); } if (opt_uninstalled) { roots = cockpit_web_server_resolve_roots (SRCDIR "/src/static", SRCDIR "/lib", NULL); cockpit_ws_bridge_program = BUILDDIR "/cockpit-bridge"; cockpit_ws_session_program = BUILDDIR "/cockpit-session"; } else { roots = cockpit_web_server_resolve_roots (DATADIR "/cockpit/static", NULL); } data.auth = cockpit_auth_new (); data.static_roots = (const gchar **)roots; server = cockpit_web_server_new (opt_port, certificate, NULL, NULL, error); if (server == NULL) { g_prefix_error (error, "Error starting web server: "); goto out; } /* Ignores stuff it shouldn't handle */ g_signal_connect (server, "handle-stream", G_CALLBACK (cockpit_handler_socket), &data); g_signal_connect (server, "handle-resource::/login", G_CALLBACK (cockpit_handler_login), &data); /* Don't redirect to TLS for /ping */ g_object_set (server, "ssl-exception-prefix", "/ping", NULL); g_signal_connect (server, "handle-resource::/ping", G_CALLBACK (cockpit_handler_ping), &data); g_signal_connect (server, "handle-resource::/", G_CALLBACK (cockpit_handler_index), &data); g_signal_connect (server, "handle-resource::/static/", G_CALLBACK (cockpit_handler_static), &data); g_signal_connect (server, "handle-resource::/cockpit/", G_CALLBACK (cockpit_handler_resource), &data); /* Files that cannot be cache-forever, because of well known names */ g_signal_connect (server, "handle-resource::/favicon.ico", G_CALLBACK (cockpit_handler_root), &data); g_signal_connect (server, "handle-resource::/apple-touch-icon.png", G_CALLBACK (cockpit_handler_root), &data); g_info ("HTTP Server listening on port %d", opt_port); loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (loop); g_main_loop_unref (loop); ret = 0; out: if (local_error) { g_printerr ("cockpit-ws: %s\n", local_error->message); g_error_free (local_error); } g_clear_object (&server); g_clear_object (&data.auth); g_clear_object (&certificate); g_free (cert_path); g_strfreev (roots); return ret; }
int main (int argc, char **argv) { GError *error; GOptionContext *opt_context; GIOChannel *channel; guint name_owner_id = 0; gint ret; ret = 1; loop = NULL; opt_context = NULL; #if !GLIB_CHECK_VERSION(2,36,0) g_type_init (); #endif /* See glib/gio/gsocket.c */ signal (SIGPIPE, SIG_IGN); /* avoid gvfs and gsettings: https://bugzilla.gnome.org/show_bug.cgi?id=767183 */ g_assert (g_setenv ("GIO_USE_VFS", "local", TRUE)); g_assert (g_setenv ("GSETTINGS_BACKEND", "memory", TRUE)); opt_context = g_option_context_new ("rpm-ostreed -- rpm-ostree daemon"); g_option_context_add_main_entries (opt_context, opt_entries, NULL); error = NULL; if (!g_option_context_parse (opt_context, &argc, &argv, &error)) { g_printerr ("Error parsing options: %s\n", error->message); g_error_free (error); goto out; } if (opt_debug) { g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_INFO, on_log_debug, NULL); g_log_set_always_fatal (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING); /* When in debug mode (often testing) we exit when stdin closes */ channel = g_io_channel_unix_new (0); g_io_add_watch (channel, G_IO_HUP, on_stdin_close, NULL); g_io_channel_unref (channel); } else { /* When not in debug mode, send all logging to syslog */ g_log_set_default_handler (on_log_handler, NULL); } g_info ("rpm-ostreed starting"); loop = g_main_loop_new (NULL, FALSE); g_unix_signal_add (SIGINT, on_sigint, NULL); g_unix_signal_add (SIGTERM, on_sigint, NULL); if (service_dbus_fd == -1) { GBusType bus_type; /* To facilitate testing, use whichever message bus activated * this process. If the process was started directly, assume * the system bus. */ if (g_getenv ("DBUS_STARTER_BUS_TYPE") != NULL) bus_type = G_BUS_TYPE_STARTER; else if (g_getenv ("RPMOSTREE_USE_SESSION_BUS") != NULL) bus_type = G_BUS_TYPE_SESSION; else bus_type = G_BUS_TYPE_SYSTEM; name_owner_id = g_bus_own_name (bus_type, DBUS_NAME, G_BUS_NAME_OWNER_FLAGS_NONE, on_bus_acquired, on_name_acquired, on_name_lost, NULL, (GDestroyNotify) NULL); } else if (!connect_to_peer (service_dbus_fd)) { ret = 1; goto out; } g_debug ("Entering main event loop"); g_main_loop_run (loop); if (name_owner_id > 0) { g_bus_unown_name (name_owner_id); name_owner_id = 0; } g_clear_object (&rpm_ostree_daemon); ret = 0; out: if (loop != NULL) g_main_loop_unref (loop); if (opt_context != NULL) g_option_context_free (opt_context); g_info ("rpm-ostreed exiting"); return ret; }
int main (int argc, char *argv[]) { gint ret = 1; CockpitWebServer *server = NULL; GOptionContext *context; CockpitHandlerData data; GError *local_error = NULL; GError **error = &local_error; GMainLoop *loop; g_type_init (); memset (&data, 0, sizeof (data)); context = g_option_context_new (NULL); g_option_context_add_main_entries (context, cmd_entries, NULL); if (!g_option_context_parse (context, &argc, &argv, error)) { goto out; } if (!opt_debug) cockpit_set_journal_logging (); if (opt_http_root == NULL) opt_http_root = g_strdup (PACKAGE_DATA_DIR "/cockpit/content"); if (opt_no_tls) { /* no certificate */ } else { if (!load_cert (&data.certificate, error)) goto out; } if (!opt_disable_auth) data.auth = cockpit_auth_new (); data.system_bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, error); if (data.system_bus == NULL) { g_prefix_error (error, "Error getting system bus: "); goto out; } server = cockpit_web_server_new (opt_port, data.certificate, opt_http_root, NULL, error); if (server == NULL) { g_prefix_error (error, "Error starting web server: "); goto out; } /* Ignores stuff it shouldn't handle */ g_signal_connect (server, "handle-resource", G_CALLBACK (cockpit_handler_socket), &data); g_signal_connect (server, "handle-resource::/login", G_CALLBACK (cockpit_handler_login), &data); g_signal_connect (server, "handle-resource::/logout", G_CALLBACK (cockpit_handler_logout), &data); g_signal_connect (server, "handle-resource::/cockpitdyn.js", G_CALLBACK (cockpit_handler_cockpitdyn), &data); g_info ("HTTP Server listening on port %d", opt_port); loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (loop); g_main_loop_unref (loop); ret = 0; out: g_free (opt_http_root); if (local_error) { g_printerr ("%s (%s, %d)\n", local_error->message, g_quark_to_string (local_error->domain), local_error->code); g_error_free (local_error); } g_clear_object (&server); g_clear_object (&data.auth); g_clear_object (&data.system_bus); g_clear_object (&data.certificate); return ret; }
/** * Initialize version string. */ void G_COLD version_init(void) { time_t now; version_string = ostrdup_readonly(version_build_string()); now = tm_time(); { bool ok; const char *end; ok = version_parse(version_string, &our_version, &end); g_assert(ok); ok = version_ext_parse(end, &our_ext_version); g_assert(ok); } g_info("%s", version_string); version_stamp(version_string, &our_version); g_assert(our_version.timestamp != 0); { char buf[128]; str_bprintf(buf, sizeof(buf), "%s/%s%s (%s)", product_name(), product_version(), product_build_full(), product_date()); version_short_string = ostrdup_readonly(buf); } last_rel_version = our_version; /* struct copy */ last_dev_version = our_version; /* struct copy */ our_ext_version.version = our_version; /* struct copy */ /* * The version code is a one-byte encoding of the year/month, since * what matters is not much the version number as to the age of the * servent... The version code is transmitted in pongs via GGEP "VC". */ if (our_version.timestamp) { struct tm *tmp = localtime(&our_version.timestamp); version_code = (((tmp->tm_year + 1900 - 2000) & 0x0f) << 4) | (tmp->tm_mon + 1); } else version_code = 0; /* * The property system is not up when this is called, but we need * to set this variable correctly. */ if ( tok_is_ancient(now) || delta_time(now, our_version.timestamp) > VERSION_ANCIENT_WARN ) { *deconstify_bool(&GNET_PROPERTY(ancient_version)) = TRUE; } }