int main (int argc, char *argv[]) { int i; int ret; // BEGIN NEW CODE server *fake_serv; GIOChannel *channel; session *sess; // END NEW CODE #ifdef WIN32 HRESULT coinit_result; #endif srand ((unsigned int) time (NULL)); /* CL: do this only once! */ /* We must check for the config dir parameter, otherwise load_config() will behave incorrectly. * load_config() must come before fe_args() because fe_args() calls gtk_init() which needs to * know the language which is set in the config. The code below is copy-pasted from fe_args() * for the most part. */ if (argc >= 2) { for (i = 1; i < argc; i++) { if ((strcmp (argv[i], "-d") == 0 || strcmp (argv[i], "--cfgdir") == 0) && i + 1 < argc) { xdir = g_strdup (argv[i + 1]); } else if (strncmp (argv[i], "--cfgdir=", 9) == 0) { xdir = g_strdup (argv[i] + 9); } if (xdir != NULL) { if (xdir[strlen (xdir) - 1] == G_DIR_SEPARATOR) { xdir[strlen (xdir) - 1] = 0; } break; } } } #if ! GLIB_CHECK_VERSION (2, 36, 0) // RFM: Don't think we hit this g_type_init (); #endif if (check_config_dir () == 0) { if (load_config () != 0) load_default_config (); } else { /* this is probably the first run */ load_default_config (); make_config_dirs (); make_dcc_dirs (); } /* we MUST do this after load_config () AND before fe_init (thus gtk_init) otherwise it will fail */ // RFM: Does nothing on *NIX set_locale (); // RFM: Parses some command line crap. Not important ret = fe_args (argc, argv); if (ret != -1) return ret; #ifdef USE_DBUS hexchat_remote (); #endif #ifdef USE_LIBPROXY // RFM: Not using libproxy_factory = px_proxy_factory_new(); #endif #ifdef WIN32 coinit_result = CoInitializeEx (NULL, COINIT_APARTMENTTHREADED); if (SUCCEEDED (coinit_result)) { CoInitializeSecurity (NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL); } #endif // RFM: Inits some fe-text stuff fe_init (); // RFM: Pretty sure this just allows us to save chats... /* This is done here because cfgfiles.c is too early in * the startup process to use gtk functions. */ if (g_access (get_xdir (), W_OK) != 0) { char buf[2048]; g_snprintf (buf, sizeof(buf), _("You do not have write access to %s. Nothing from this session can be saved."), get_xdir ()); fe_message (buf, FE_MSG_ERROR); } // RFM: Checks if root on *NIX #ifndef WIN32 #ifndef __EMX__ /* OS/2 uses UID 0 all the time */ if (getuid () == 0) fe_message (_("* Running IRC as root is stupid! You should\n" " create a User Account and use that to login.\n"), FE_MSG_WARN|FE_MSG_WAIT); #endif #endif /* !WIN32 */ // RFM: Loads a bunch of configure options xchat_init (); // BEGIN NEW CODE fake_serv = server_new(); fake_serv->sok = STDIN_FILENO; // fake_serv->pos = 0; //??? sess = session_new(fake_serv, "fake_sess", SESS_CHANNEL, 0); fake_serv->server_session = sess; fake_serv->front_session = sess; channel = g_io_channel_unix_new(STDIN_FILENO); g_io_add_watch(channel, G_IO_IN, (GIOFunc)server_read, fake_serv); //g_io_add_watch(channel, G_IO_IN, (GIOFunc)io_callback, fake_serv); g_io_channel_unref(channel); // END NEW CODE fe_main (); #ifdef WIN32 if (SUCCEEDED (coinit_result)) { CoUninitialize (); } #endif #ifdef USE_LIBPROXY px_proxy_factory_free(libproxy_factory); #endif #ifdef WIN32 WSACleanup (); #endif return 0; }
int main (int argc, char *argv[]) { int i; int ret; srand (time (0)); /* CL: do this only once! */ /* We must check for the config dir parameter, otherwise load_config() will behave incorrectly. * load_config() must come before fe_args() because fe_args() calls gtk_init() which needs to * know the language which is set in the config. The code below is copy-pasted from fe_args() * for the most part. */ if (argc >= 2) { for (i = 1; i < argc; i++) { if ((strcmp (argv[i], "-d") == 0 || strcmp (argv[i], "--cfgdir") == 0) && i + 1 < argc) { xdir = strdup (argv[i + 1]); } else if (strncmp (argv[i], "--cfgdir=", 9) == 0) { xdir = strdup (argv[i] + 9); } if (xdir != NULL) { if (xdir[strlen (xdir) - 1] == G_DIR_SEPARATOR) { xdir[strlen (xdir) - 1] = 0; } break; } } } #if ! GLIB_CHECK_VERSION (2, 36, 0) g_type_init (); #endif if (check_config_dir () == 0) { if (load_config () != 0) load_default_config (); } else { /* this is probably the first run */ load_default_config (); make_config_dirs (); make_dcc_dirs (); } /* we MUST do this after load_config () AND before fe_init (thus gtk_init) otherwise it will fail */ set_locale (); #ifdef SOCKS SOCKSinit (argv[0]); #endif ret = fe_args (argc, argv); if (ret != -1) return ret; #ifdef USE_DBUS hexchat_remote (); #endif #ifdef USE_LIBPROXY libproxy_factory = px_proxy_factory_new(); #endif fe_init (); /* This is done here because cfgfiles.c is too early in * the startup process to use gtk functions. */ if (g_access (get_xdir (), W_OK) != 0) { char buf[2048]; g_snprintf (buf, sizeof(buf), _("You do not have write access to %s. Nothing from this session can be saved."), get_xdir ()); fe_message (buf, FE_MSG_ERROR); } #ifndef WIN32 #ifndef __EMX__ /* OS/2 uses UID 0 all the time */ if (getuid () == 0) fe_message (_("* Running IRC as root is stupid! You should\n" " create a User Account and use that to login.\n"), FE_MSG_WARN|FE_MSG_WAIT); #endif #endif /* !WIN32 */ xchat_init (); fe_main (); #ifdef USE_LIBPROXY px_proxy_factory_free(libproxy_factory); #endif #ifdef WIN32 WSACleanup (); #endif return 0; }
int trg_client_populate_with_settings(TrgClient * tc) { TrgClientPrivate *priv = tc->priv; TrgPrefs *prefs = priv->prefs; gint port; gchar *host, *path; #ifdef HAVE_LIBPROXY pxProxyFactory *pf = NULL; #endif g_mutex_lock(&priv->configMutex); trg_prefs_set_connection(prefs, trg_prefs_get_profile(prefs)); g_free(priv->url); priv->url = NULL; g_free(priv->username); priv->username = NULL; g_free(priv->password); priv->password = NULL; port = trg_prefs_get_int(prefs, TRG_PREFS_KEY_PORT, TRG_PREFS_CONNECTION); host = trg_prefs_get_string(prefs, TRG_PREFS_KEY_HOSTNAME, TRG_PREFS_CONNECTION); path = trg_prefs_get_string(prefs, TRG_PREFS_KEY_RPC_URL_PATH, TRG_PREFS_CONNECTION); if (!host || strlen(host) < 1) { g_free(host); g_mutex_unlock(&priv->configMutex); return TRG_NO_HOSTNAME_SET; } #ifndef CURL_NO_SSL priv->ssl = trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SSL, TRG_PREFS_CONNECTION); priv->ssl_validate = trg_prefs_get_bool(prefs, TRG_PREFS_KEY_SSL_VALIDATE, TRG_PREFS_CONNECTION); #else priv->ssl = FALSE; #endif priv->url = g_strdup_printf("%s://%s:%d%s", priv->ssl ? HTTPS_URI_PREFIX : HTTP_URI_PREFIX, host, port, path); g_free(host); g_free(path); priv->username = trg_prefs_get_string(prefs, TRG_PREFS_KEY_USERNAME, TRG_PREFS_CONNECTION); priv->password = trg_prefs_get_string(prefs, TRG_PREFS_KEY_PASSWORD, TRG_PREFS_CONNECTION); g_free(priv->proxy); priv->proxy = NULL; #ifdef HAVE_LIBPROXY if ((pf = px_proxy_factory_new())) { char **proxies = px_proxy_factory_get_proxies(pf, priv->url); int i; for (i = 0; proxies[i]; i++) { if (g_str_has_prefix(proxies[i], HTTP_URI_PREFIX) || g_str_has_prefix(proxies[i], HTTPS_URI_PREFIX)) { g_free(priv->proxy); priv->proxy = proxies[i]; } else { g_free(proxies[i]); } } g_free(proxies); px_proxy_factory_free(pf); } #endif priv->configSerial++; g_mutex_unlock(&priv->configMutex); return 0; }
void ne_session_system_proxy(ne_session *sess, unsigned int flags) { #ifdef HAVE_LIBPROXY pxProxyFactory *pxf = px_proxy_factory_new(); struct host_info *hi, **lasthi; char *url, **proxies; ne_uri uri; unsigned n; free_proxies(sess); /* Create URI for session to pass off to libproxy */ memset(&uri, 0, sizeof uri); ne_fill_server_uri(sess, &uri); uri.path = "/"; /* make valid URI structure. */ url = ne_uri_unparse(&uri); uri.path = NULL; /* Get list of pseudo-URIs from libproxy: */ proxies = px_proxy_factory_get_proxies(pxf, url); for (n = 0, lasthi = &sess->proxies; proxies[n]; n++) { enum proxy_type ptype; ne_uri_free(&uri); NE_DEBUG(NE_DBG_HTTP, "sess: libproxy #%u=%s\n", n, proxies[n]); if (ne_uri_parse(proxies[n], &uri)) continue; if (!uri.scheme) continue; if (ne_strcasecmp(uri.scheme, "http") == 0) ptype = PROXY_HTTP; else if (ne_strcasecmp(uri.scheme, "socks") == 0) ptype = PROXY_SOCKS; else if (ne_strcasecmp(uri.scheme, "direct") == 0) ptype = PROXY_NONE; else continue; /* Hostname/port required for http/socks schemes. */ if (ptype != PROXY_NONE && !(uri.host && uri.port)) continue; /* Do nothing if libproxy returned only a single "direct://" * entry -- a single "direct" (noop) proxy is equivalent to * having none. */ if (n == 0 && proxies[1] == NULL && ptype == PROXY_NONE) break; NE_DEBUG(NE_DBG_HTTP, "sess: Got proxy %s://%s:%d\n", uri.scheme, uri.host ? uri.host : "(none)", uri.port); hi = *lasthi = ne_calloc(sizeof *hi); if (ptype == PROXY_NONE) { /* A "direct" URI requires an attempt to connect directly to * the origin server, so dup the server details. */ set_hostinfo(hi, ptype, sess->server.hostname, sess->server.port); } else { /* SOCKS/HTTP proxy. */ set_hostinfo(hi, ptype, uri.host, uri.port); if (ptype == PROXY_HTTP) sess->any_proxy_http = 1; else if (ptype == PROXY_SOCKS) sess->socks_ver = NE_SOCK_SOCKSV5; } lasthi = &hi->next; } /* Free up the proxies array: */ for (n = 0; proxies[n]; n++) free(proxies[n]); free(proxies[n]); ne_free(url); ne_uri_free(&uri); px_proxy_factory_free(pxf); #endif }
int main(int argc, char **argv) { struct openconnect_info *vpninfo; char *urlpath = NULL; char *proxy = getenv("https_proxy"); char *vpnc_script = NULL, *ifname = NULL; const struct oc_ip_info *ip_info; int autoproxy = 0; int opt; char *pidfile = NULL; int use_dtls = 1; FILE *fp = NULL; char *config_arg; char *token_str = NULL; oc_token_mode_t token_mode = OC_TOKEN_MODE_NONE; int reconnect_timeout = 300; int ret; #ifndef _WIN32 struct sigaction sa; struct utsname utsbuf; uid_t uid = getuid(); int use_syslog = 0; int script_tun = 0; #endif #ifdef ENABLE_NLS bindtextdomain("openconnect", LOCALEDIR); setlocale(LC_ALL, ""); #endif if (strcmp(openconnect_version_str, openconnect_binary_version)) { fprintf(stderr, _("WARNING: This version of openconnect is %s but\n" " the libopenconnect library is %s\n"), openconnect_binary_version, openconnect_version_str); } openconnect_init_ssl(); vpninfo = openconnect_vpninfo_new((char *)"Open AnyConnect VPN Agent", validate_peer_cert, NULL, process_auth_form_cb, write_progress, NULL); if (!vpninfo) { fprintf(stderr, _("Failed to allocate vpninfo structure\n")); exit(1); } vpninfo->cbdata = vpninfo; #ifdef _WIN32 set_default_vpncscript(); #else if (!uname(&utsbuf)) { free(vpninfo->localname); vpninfo->localname = xstrdup(utsbuf.nodename); } #endif while ((opt = next_option(argc, argv, &config_arg))) { if (opt < 0) break; switch (opt) { case OPT_CONFIGFILE: if (config_file) { fprintf(stderr, _("Cannot use 'config' option inside config file\n")); exit(1); } config_file = fopen(config_arg, "r"); if (!config_file) { fprintf(stderr, _("Cannot open config file '%s': %s\n"), config_arg, strerror(errno)); exit(1); } config_line_num = 1; /* The next option will come from the file... */ break; case OPT_CAFILE: openconnect_set_cafile(vpninfo, xstrdup(config_arg)); break; case OPT_PIDFILE: pidfile = keep_config_arg(); break; case OPT_PFS: openconnect_set_pfs(vpninfo, 1); break; case OPT_SERVERCERT: openconnect_set_server_cert_sha1(vpninfo, xstrdup(config_arg)); break; case OPT_NO_DTLS: use_dtls = 0; break; case OPT_COOKIEONLY: cookieonly = 1; break; case OPT_PRINTCOOKIE: cookieonly = 2; break; case OPT_AUTHENTICATE: cookieonly = 3; break; case OPT_COOKIE_ON_STDIN: read_stdin(&vpninfo->cookie, 0); /* If the cookie is empty, ignore it */ if (!*vpninfo->cookie) vpninfo->cookie = NULL; break; case OPT_PASSWORD_ON_STDIN: read_stdin(&password, 0); break; case OPT_NO_PASSWD: vpninfo->nopasswd = 1; break; case OPT_NO_XMLPOST: openconnect_set_xmlpost(vpninfo, 0); break; case OPT_NON_INTER: non_inter = 1; break; case OPT_RECONNECT_TIMEOUT: reconnect_timeout = atoi(config_arg); break; case OPT_DTLS_CIPHERS: vpninfo->dtls_ciphers = keep_config_arg(); break; case OPT_AUTHGROUP: authgroup = keep_config_arg(); break; #ifndef _WIN32 case 'b': background = 1; break; #endif case 'C': vpninfo->cookie = strdup(config_arg); break; case 'c': vpninfo->cert = strdup(config_arg); break; case 'e': vpninfo->cert_expire_warning = 86400 * atoi(config_arg); break; case 'k': vpninfo->sslkey = strdup(config_arg); break; case 'd': vpninfo->deflate = 1; break; case 'D': vpninfo->deflate = 0; break; case 'g': free(urlpath); urlpath = strdup(config_arg); break; case 'h': usage(); case 'i': ifname = xstrdup(config_arg); break; #ifndef _WIN32 case 'l': use_syslog = 1; break; #endif case 'm': { int mtu = atol(config_arg); if (mtu < 576) { fprintf(stderr, _("MTU %d too small\n"), mtu); mtu = 576; } openconnect_set_reqmtu(vpninfo, mtu); break; } case OPT_BASEMTU: vpninfo->basemtu = atol(config_arg); if (vpninfo->basemtu < 576) { fprintf(stderr, _("MTU %d too small\n"), vpninfo->basemtu); vpninfo->basemtu = 576; } break; case 'p': vpninfo->cert_password = strdup(config_arg); break; case 'P': proxy = keep_config_arg(); autoproxy = 0; break; case OPT_PROXY_AUTH: openconnect_set_proxy_auth(vpninfo, xstrdup(config_arg)); break; case OPT_NO_PROXY: autoproxy = 0; proxy = NULL; break; case OPT_LIBPROXY: autoproxy = 1; proxy = NULL; break; case OPT_NO_HTTP_KEEPALIVE: fprintf(stderr, _("Disabling all HTTP connection re-use due to --no-http-keepalive option.\n" "If this helps, please report to <*****@*****.**>.\n")); vpninfo->no_http_keepalive = 1; break; case OPT_NO_CERT_CHECK: nocertcheck = 1; break; case 's': vpnc_script = xstrdup(config_arg); break; #ifndef _WIN32 case 'S': script_tun = 1; break; #endif case 'u': free(username); username = strdup(config_arg); break; #ifndef _WIN32 case 'U': { char *strend; uid = strtol(config_arg, &strend, 0); if (strend[0]) { struct passwd *pw = getpwnam(config_arg); if (!pw) { fprintf(stderr, _("Invalid user \"%s\"\n"), config_arg); exit(1); } uid = pw->pw_uid; } break; } case OPT_CSD_USER: { char *strend; vpninfo->uid_csd = strtol(config_arg, &strend, 0); if (strend[0]) { struct passwd *pw = getpwnam(config_arg); if (!pw) { fprintf(stderr, _("Invalid user \"%s\"\n"), config_arg); exit(1); } vpninfo->uid_csd = pw->pw_uid; } vpninfo->uid_csd_given = 1; break; } case OPT_CSD_WRAPPER: vpninfo->csd_wrapper = keep_config_arg(); break; #endif case OPT_DISABLE_IPV6: vpninfo->disable_ipv6 = 1; break; case 'Q': vpninfo->max_qlen = atol(config_arg); if (!vpninfo->max_qlen) { fprintf(stderr, _("Queue length zero not permitted; using 1\n")); vpninfo->max_qlen = 1; } break; case 'q': verbose = PRG_ERR; break; case OPT_DUMP_HTTP: vpninfo->dump_http_traffic = 1; break; case 'v': verbose++; break; case 'V': printf(_("OpenConnect version %s\n"), openconnect_version_str); print_build_opts(); exit(0); case 'x': vpninfo->xmlconfig = keep_config_arg(); vpninfo->write_new_config = write_new_config; break; case OPT_KEY_PASSWORD_FROM_FSID: do_passphrase_from_fsid = 1; break; case OPT_USERAGENT: free(vpninfo->useragent); vpninfo->useragent = strdup(config_arg); break; case OPT_FORCE_DPD: openconnect_set_dpd(vpninfo, atoi(config_arg)); break; case OPT_DTLS_LOCAL_PORT: vpninfo->dtls_local_port = atoi(config_arg); break; case OPT_TOKEN_MODE: if (strcasecmp(config_arg, "rsa") == 0) { token_mode = OC_TOKEN_MODE_STOKEN; } else if (strcasecmp(config_arg, "totp") == 0) { token_mode = OC_TOKEN_MODE_TOTP; } else if (strcasecmp(config_arg, "hotp") == 0) { token_mode = OC_TOKEN_MODE_HOTP; } else { fprintf(stderr, _("Invalid software token mode \"%s\"\n"), config_arg); exit(1); } break; case OPT_TOKEN_SECRET: token_str = keep_config_arg(); break; case OPT_OS: if (openconnect_set_reported_os(vpninfo, config_arg)) { fprintf(stderr, _("Invalid OS identity \"%s\"\n"), config_arg); exit(1); } if (!strcmp(config_arg, "android") || !strcmp(config_arg, "apple-ios")) { /* generic defaults */ openconnect_set_mobile_info(vpninfo, xstrdup("1.0"), xstrdup(config_arg), xstrdup("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")); } break; case OPT_TIMESTAMP: timestamp = 1; break; default: usage(); } } if (optind < argc - 1) { fprintf(stderr, _("Too many arguments on command line\n")); usage(); } else if (optind > argc - 1) { fprintf(stderr, _("No server specified\n")); usage(); } if (!vpninfo->sslkey) vpninfo->sslkey = vpninfo->cert; if (vpninfo->dump_http_traffic && verbose < PRG_DEBUG) verbose = PRG_DEBUG; vpninfo->progress = write_progress; if (autoproxy) { #ifdef LIBPROXY_HDR vpninfo->proxy_factory = px_proxy_factory_new(); #else fprintf(stderr, _("This version of openconnect was built without libproxy support\n")); exit(1); #endif } if (token_mode != OC_TOKEN_MODE_NONE) init_token(vpninfo, token_mode, token_str); if (proxy && openconnect_set_http_proxy(vpninfo, strdup(proxy))) exit(1); #ifndef _WIN32 if (use_syslog) { #ifndef __ANDROID__ openlog("openconnect", LOG_PID, LOG_DAEMON); #endif vpninfo->progress = syslog_progress; } #endif /* !_WIN32 */ sig_cmd_fd = openconnect_setup_cmd_pipe(vpninfo); if (sig_cmd_fd < 0) { fprintf(stderr, _("Error opening cmd pipe\n")); exit(1); } #ifndef _WIN32 memset(&sa, 0, sizeof(sa)); sa.sa_handler = handle_signal; sigaction(SIGINT, &sa, NULL); sigaction(SIGHUP, &sa, NULL); sigaction(SIGUSR2, &sa, NULL); #endif /* !_WIN32 */ if (vpninfo->sslkey && do_passphrase_from_fsid) openconnect_passphrase_from_fsid(vpninfo); if (config_lookup_host(vpninfo, argv[optind])) exit(1); if (!vpninfo->hostname) { char *url = strdup(argv[optind]); if (openconnect_parse_url(vpninfo, url)) exit(1); free(url); } /* Historically, the path in the URL superseded the one in the * --usergroup argument, just because of the order in which they * were processed. Preserve that behaviour. */ if (urlpath && !vpninfo->urlpath) { vpninfo->urlpath = urlpath; urlpath = NULL; } free(urlpath); #ifdef SSL_UI set_openssl_ui(); #endif if (!vpninfo->cookie && openconnect_obtain_cookie(vpninfo)) { if (vpninfo->csd_scriptname) { unlink(vpninfo->csd_scriptname); vpninfo->csd_scriptname = NULL; } fprintf(stderr, _("Failed to obtain WebVPN cookie\n")); exit(1); } if (cookieonly == 3) { /* --authenticate */ printf("COOKIE='%s'\n", vpninfo->cookie); printf("HOST='%s'\n", openconnect_get_hostname(vpninfo)); if (vpninfo->peer_cert) { char buf[41] = {0, }; openconnect_get_cert_sha1(vpninfo, vpninfo->peer_cert, buf); printf("FINGERPRINT='%s'\n", buf); } openconnect_vpninfo_free(vpninfo); exit(0); } else if (cookieonly) { printf("%s\n", vpninfo->cookie); if (cookieonly == 1) { /* We use cookieonly=2 for 'print it and continue' */ openconnect_vpninfo_free(vpninfo); exit(0); } } if (openconnect_make_cstp_connection(vpninfo)) { fprintf(stderr, _("Creating SSL connection failed\n")); openconnect_vpninfo_free(vpninfo); exit(1); } if (!vpnc_script) vpnc_script = xstrdup(default_vpncscript); #ifndef _WIN32 if (script_tun) { if (openconnect_setup_tun_script(vpninfo, vpnc_script)) { fprintf(stderr, _("Set up tun script failed\n")); openconnect_vpninfo_free(vpninfo); exit(1); } } else #endif if (openconnect_setup_tun_device(vpninfo, vpnc_script, ifname)) { fprintf(stderr, _("Set up tun device failed\n")); openconnect_vpninfo_free(vpninfo); exit(1); } #ifndef _WIN32 if (uid != getuid()) { if (setuid(uid)) { fprintf(stderr, _("Failed to set uid %ld\n"), (long)uid); openconnect_vpninfo_free(vpninfo); exit(1); } } #endif if (use_dtls && openconnect_setup_dtls(vpninfo, 60)) fprintf(stderr, _("Set up DTLS failed; using SSL instead\n")); openconnect_get_ip_info(vpninfo, &ip_info, NULL, NULL); vpn_progress(vpninfo, PRG_INFO, _("Connected %s as %s%s%s, using %s\n"), openconnect_get_ifname(vpninfo), ip_info->addr?:"", (ip_info->netmask6 && ip_info->addr) ? " + " : "", ip_info->netmask6 ? : "", (vpninfo->dtls_state != DTLS_CONNECTED) ? (vpninfo->deflate ? "SSL + deflate" : "SSL") : "DTLS"); if (!vpninfo->vpnc_script) { vpn_progress(vpninfo, PRG_INFO, _("No --script argument provided; DNS and routing are not configured\n")); vpn_progress(vpninfo, PRG_INFO, _("See http://www.infradead.org/openconnect/vpnc-script.html\n")); } #ifndef _WIN32 if (background) { int pid; /* Open the pidfile before forking, so we can report errors more sanely. It's *possible* that we'll fail to write to it, but very unlikely. */ if (pidfile != NULL) { fp = fopen(pidfile, "w"); if (!fp) { fprintf(stderr, _("Failed to open '%s' for write: %s\n"), pidfile, strerror(errno)); openconnect_vpninfo_free(vpninfo); exit(1); } } if ((pid = fork())) { if (fp) { fprintf(fp, "%d\n", pid); fclose(fp); } vpn_progress(vpninfo, PRG_INFO, _("Continuing in background; pid %d\n"), pid); openconnect_vpninfo_free(vpninfo); exit(0); } if (fp) fclose(fp); } #endif while (1) { ret = openconnect_mainloop(vpninfo, reconnect_timeout, RECONNECT_INTERVAL_MIN); if (ret) break; vpn_progress(vpninfo, PRG_INFO, _("User requested reconnect\n")); } if (fp) unlink(pidfile); switch (ret) { case -EPERM: vpn_progress(vpninfo, PRG_ERR, _("Cookie was rejected on reconnection; exiting.\n")); ret = 2; break; case -EPIPE: vpn_progress(vpninfo, PRG_ERR, _("Session terminated by server; exiting.\n")); ret = 1; break; case -EINTR: vpn_progress(vpninfo, PRG_INFO, _("User canceled (SIGINT); exiting.\n")); ret = 0; break; case -ECONNABORTED: vpn_progress(vpninfo, PRG_INFO, _("User detached from session (SIGHUP); exiting.\n")); ret = 0; break; default: vpn_progress(vpninfo, PRG_ERR, _("Unknown error; exiting.\n")); ret = 1; break; } openconnect_vpninfo_free(vpninfo); exit(ret); }
static void g_libproxy_resolver_init (GLibProxyResolver *resolver) { resolver->factory = px_proxy_factory_new (); }
static void update_proxy_settings (void) { char *mode, *http_proxy, *https_proxy = NULL, *no_proxy = NULL; GSList *ignore; /* resolver_gnome is locked */ if (proxy_user) { g_free (proxy_user); proxy_user = NULL; } if (proxy_password) { memset (proxy_password, 0, strlen (proxy_password)); g_free (proxy_password); proxy_password = NULL; } /* Get new settings */ mode = gconf_client_get_string ( gconf_client, SOUP_GCONF_PROXY_MODE, NULL); if (!mode || !gconf_string_to_enum (proxy_mode_map, mode, (int *)&proxy_mode)) proxy_mode = SOUP_PROXY_RESOLVER_GNOME_MODE_NONE; g_free (mode); if (proxy_mode == SOUP_PROXY_RESOLVER_GNOME_MODE_NONE) { if (libproxy_factory) { /* Unset anything we previously set */ g_unsetenv ("PX_CONFIG_ORDER"); g_unsetenv ("http_proxy"); g_unsetenv ("https_proxy"); g_unsetenv ("no_proxy"); } return; } else if (proxy_mode == SOUP_PROXY_RESOLVER_GNOME_MODE_AUTO) { char *autoconfig_url; autoconfig_url = gconf_client_get_string ( gconf_client, SOUP_GCONF_PROXY_AUTOCONFIG_URL, NULL); if (autoconfig_url && !strncmp (autoconfig_url, "http", 4)) http_proxy = g_strconcat ("pac+", autoconfig_url, NULL); else http_proxy = g_strdup ("wpad://"); g_free (autoconfig_url); } else /* SOUP_PROXY_RESOLVER_GNOME_MODE_MANUAL */ { char *host; guint port; host = gconf_client_get_string ( gconf_client, SOUP_GCONF_HTTP_PROXY_HOST, NULL); if (!host || !*host) { g_free (host); proxy_mode = SOUP_PROXY_RESOLVER_GNOME_MODE_NONE; return; } port = gconf_client_get_int ( gconf_client, SOUP_GCONF_HTTP_PROXY_PORT, NULL); if (port) { http_proxy = g_strdup_printf ("http://%s:%u", host, port); } else http_proxy = g_strdup_printf ("http://%s", host); g_free (host); if (!gconf_client_get_bool (gconf_client, SOUP_GCONF_USE_SAME_PROXY, NULL)) { host = gconf_client_get_string ( gconf_client, SOUP_GCONF_HTTPS_PROXY_HOST, NULL); port = gconf_client_get_int ( gconf_client, SOUP_GCONF_HTTPS_PROXY_PORT, NULL); if (host && *host) { if (port) { https_proxy = g_strdup_printf ( "http://%s:%u", host, port); } else { https_proxy = g_strdup_printf ( "http://%s", host); } } g_free (host); } if (gconf_client_get_bool (gconf_client, SOUP_GCONF_HTTP_USE_AUTH, NULL)) { proxy_user = gconf_client_get_string ( gconf_client, SOUP_GCONF_HTTP_PROXY_USER, NULL); proxy_password = gconf_client_get_string ( gconf_client, SOUP_GCONF_HTTP_PROXY_PASSWORD, NULL); } } ignore = gconf_client_get_list ( gconf_client, SOUP_GCONF_PROXY_IGNORE_HOSTS, GCONF_VALUE_STRING, NULL); if (ignore) { GString *ignore_list; GSList *i; ignore_list = g_string_new (NULL); for (i = ignore; i; i = i->next) { if (ignore_list->len) g_string_append_c (ignore_list, ','); g_string_append (ignore_list, i->data); g_free (i->data); } g_slist_free (ignore); no_proxy = g_string_free (ignore_list, FALSE); } g_setenv ("PX_CONFIG_ORDER", "envvar", TRUE); g_setenv ("http_proxy", http_proxy, TRUE); g_free (http_proxy); if (https_proxy) { g_setenv ("https_proxy", https_proxy, TRUE); g_free (https_proxy); } else g_unsetenv ("https_proxy"); if (no_proxy) { g_setenv ("no_proxy", no_proxy, TRUE); g_free (no_proxy); } else g_unsetenv ("no_proxy"); /* If we haven't created a proxy factory or thread pool yet, * do so. If we already have one, we don't need to update * anything, because it rechecks the environment variables * every time. */ if (!libproxy_factory) libproxy_factory = px_proxy_factory_new (); if (proxy_mode == SOUP_PROXY_RESOLVER_GNOME_MODE_AUTO && !libproxy_threadpool) { libproxy_threadpool = g_thread_pool_new (libproxy_threadpool_func, NULL, -1, FALSE, NULL); } }
nsresult nsUnixSystemProxySettings::GetProxyForURI(nsIURI* aURI, nsACString& aResult) { nsresult rv; if (!mProxyFactory) { mProxyFactory = px_proxy_factory_new(); } NS_ENSURE_TRUE(mProxyFactory, NS_ERROR_NOT_AVAILABLE); nsCOMPtr<nsIIOService> ios = do_GetIOService(&rv); NS_ENSURE_SUCCESS(rv, rv); nsCAutoString spec; rv = aURI->GetSpec(spec); NS_ENSURE_SUCCESS(rv, rv); char **proxyArray = nsnull; proxyArray = px_proxy_factory_get_proxies(mProxyFactory, (char*)(spec.get())); NS_ENSURE_TRUE(proxyArray, NS_ERROR_NOT_AVAILABLE); // Translate libproxy's output to PAC string as expected // libproxy returns an array of proxies in the format: // <procotol>://[username:password@]proxy:port // or // direct:// // // PAC format: "PROXY proxy1.foo.com:8080; PROXY proxy2.foo.com:8080; DIRECT" int c = 0; while (proxyArray[c] != NULL) { if (!aResult.IsEmpty()) { aResult.AppendLiteral("; "); } bool isScheme = false; nsXPIDLCString schemeString; nsXPIDLCString hostPortString; nsCOMPtr<nsIURI> proxyURI; rv = ios->NewURI(nsDependentCString(proxyArray[c]), nsnull, nsnull, getter_AddRefs(proxyURI)); if (NS_FAILED(rv)) { c++; continue; } proxyURI->GetScheme(schemeString); if (NS_SUCCEEDED(proxyURI->SchemeIs("http", &isScheme)) && isScheme) { schemeString.AssignLiteral("proxy"); } aResult.Append(schemeString); if (NS_SUCCEEDED(proxyURI->SchemeIs("direct", &isScheme)) && !isScheme) { // Add the proxy URI only if it's not DIRECT proxyURI->GetHostPort(hostPortString); aResult.AppendLiteral(" "); aResult.Append(hostPortString); } c++; } #ifdef DEBUG printf("returned PAC proxy string: %s\n", PromiseFlatCString(aResult).get()); #endif PR_Free(proxyArray); return NS_OK; }
int main (int argc, char *argv[]) { int i; int ret; #ifdef WIN32 char hexchat_lang[13]; /* LC_ALL= plus 5 chars of hex_gui_lang and trailing \0 */ #endif srand (time (0)); /* CL: do this only once! */ /* We must check for the config dir parameter, otherwise load_config() will behave incorrectly. * load_config() must come before fe_args() because fe_args() calls gtk_init() which needs to * know the language which is set in the config. The code below is copy-pasted from fe_args() * for the most part. */ if (argc >= 3) { for (i = 1; i < argc - 1; i++) { if (strcmp (argv[i], "-d") == 0) { if (xdir) { g_free (xdir); } xdir = strdup (argv[i + 1]); if (xdir[strlen (xdir) - 1] == G_DIR_SEPARATOR) { xdir[strlen (xdir) - 1] = 0; } } } } #if ! GLIB_CHECK_VERSION (2, 36, 0) g_type_init (); #endif load_config (); #ifdef WIN32 /* we MUST do this after load_config () AND before fe_init (thus gtk_init) otherwise it will fail */ strcpy (hexchat_lang, "LC_ALL="); /* this must be ordered EXACTLY as langsmenu[] */ switch (prefs.hex_gui_lang) { case 0: strcat (hexchat_lang, "af"); break; case 1: strcat (hexchat_lang, "sq"); break; case 2: strcat (hexchat_lang, "am"); break; case 3: strcat (hexchat_lang, "ast"); break; case 4: strcat (hexchat_lang, "az"); break; case 5: strcat (hexchat_lang, "eu"); break; case 6: strcat (hexchat_lang, "be"); break; case 7: strcat (hexchat_lang, "bg"); break; case 8: strcat (hexchat_lang, "ca"); break; case 9: strcat (hexchat_lang, "zh_CN"); break; case 10: strcat (hexchat_lang, "zh_TW"); break; case 11: strcat (hexchat_lang, "cs"); break; case 12: strcat (hexchat_lang, "da"); break; case 13: strcat (hexchat_lang, "nl"); break; case 14: strcat (hexchat_lang, "en_GB"); break; case 15: strcat (hexchat_lang, "en"); break; case 16: strcat (hexchat_lang, "et"); break; case 17: strcat (hexchat_lang, "fi"); break; case 18: strcat (hexchat_lang, "fr"); break; case 19: strcat (hexchat_lang, "gl"); break; case 20: strcat (hexchat_lang, "de"); break; case 21: strcat (hexchat_lang, "el"); break; case 22: strcat (hexchat_lang, "gu"); break; case 23: strcat (hexchat_lang, "hi"); break; case 24: strcat (hexchat_lang, "hu"); break; case 25: strcat (hexchat_lang, "id"); break; case 26: strcat (hexchat_lang, "it"); break; case 27: strcat (hexchat_lang, "ja"); break; case 28: strcat (hexchat_lang, "kn"); break; case 29: strcat (hexchat_lang, "rw"); break; case 30: strcat (hexchat_lang, "ko"); break; case 31: strcat (hexchat_lang, "lv"); break; case 32: strcat (hexchat_lang, "lt"); break; case 33: strcat (hexchat_lang, "mk"); break; case 34: strcat (hexchat_lang, "ml"); break; case 35: strcat (hexchat_lang, "ms"); break; case 36: strcat (hexchat_lang, "nb"); break; case 37: strcat (hexchat_lang, "no"); break; case 38: strcat (hexchat_lang, "pl"); break; case 39: strcat (hexchat_lang, "pt"); break; case 40: strcat (hexchat_lang, "pt_BR"); break; case 41: strcat (hexchat_lang, "pa"); break; case 42: strcat (hexchat_lang, "ru"); break; case 43: strcat (hexchat_lang, "sr"); break; case 44: strcat (hexchat_lang, "sk"); break; case 45: strcat (hexchat_lang, "sl"); break; case 46: strcat (hexchat_lang, "es"); break; case 47: strcat (hexchat_lang, "sv"); break; case 48: strcat (hexchat_lang, "th"); break; case 49: strcat (hexchat_lang, "uk"); break; case 50: strcat (hexchat_lang, "vi"); break; case 51: strcat (hexchat_lang, "wa"); break; default: strcat (hexchat_lang, "en"); break; } putenv (hexchat_lang); #endif #ifdef SOCKS SOCKSinit (argv[0]); #endif ret = fe_args (argc, argv); if (ret != -1) return ret; #ifdef USE_DBUS hexchat_remote (); #endif #ifdef USE_LIBPROXY libproxy_factory = px_proxy_factory_new(); #endif fe_init (); xchat_init (); fe_main (); #ifdef USE_LIBPROXY px_proxy_factory_free(libproxy_factory); #endif #ifdef USE_OPENSSL if (ctx) _SSL_context_free (ctx); #endif #ifdef USE_DEBUG hexchat_mem_list (); #endif #ifdef WIN32 WSACleanup (); #endif return 0; }
static void create_proxy_factory() { pf = px_proxy_factory_new(); }
int main (int argc, char *argv[]) { int ret; #ifdef WIN32 char hexchat_lang[13]; /* LC_ALL= plus 5 chars of gui_lang and trailing \0 */ HANDLE mutex; #endif srand (time (0)); /* CL: do this only once! */ load_config (); #ifdef WIN32 /* we MUST do this after load_config () AND before fe_init (thus gtk_init) otherwise it will fail */ strcpy (hexchat_lang, "LC_ALL="); switch (prefs.gui_lang) { case 0: strcat (hexchat_lang, "sq"); break; case 1: strcat (hexchat_lang, "am"); break; case 2: strcat (hexchat_lang, "az"); break; case 3: strcat (hexchat_lang, "eu"); break; case 4: strcat (hexchat_lang, "be"); break; case 5: strcat (hexchat_lang, "bg"); break; case 6: strcat (hexchat_lang, "ca"); break; case 7: strcat (hexchat_lang, "zh_CN"); break; case 8: strcat (hexchat_lang, "zh_TW"); break; case 9: strcat (hexchat_lang, "cs"); break; case 10: strcat (hexchat_lang, "nl"); break; case 11: strcat (hexchat_lang, "en_GB"); break; case 12: strcat (hexchat_lang, "en_US"); break; case 13: strcat (hexchat_lang, "et"); break; case 14: strcat (hexchat_lang, "fi"); break; case 15: strcat (hexchat_lang, "fr"); break; case 16: strcat (hexchat_lang, "gl"); break; case 17: strcat (hexchat_lang, "de"); break; case 18: strcat (hexchat_lang, "el"); break; case 19: strcat (hexchat_lang, "hi"); break; case 20: strcat (hexchat_lang, "hu_HU"); break; case 21: strcat (hexchat_lang, "it"); break; case 22: strcat (hexchat_lang, "ja"); break; case 23: strcat (hexchat_lang, "kn"); break; case 24: strcat (hexchat_lang, "ko"); break; case 25: strcat (hexchat_lang, "lv"); break; case 26: strcat (hexchat_lang, "lt"); break; case 27: strcat (hexchat_lang, "mk"); break; case 28: strcat (hexchat_lang, "ms"); break; case 29: strcat (hexchat_lang, "nb"); break; case 30: strcat (hexchat_lang, "no"); break; case 31: strcat (hexchat_lang, "pl"); break; case 32: strcat (hexchat_lang, "pt"); break; case 33: strcat (hexchat_lang, "pt_BR"); break; case 34: strcat (hexchat_lang, "pa"); break; case 35: strcat (hexchat_lang, "ru"); break; case 36: strcat (hexchat_lang, "sr"); break; case 37: strcat (hexchat_lang, "sk"); break; case 38: strcat (hexchat_lang, "sl"); break; case 39: strcat (hexchat_lang, "es"); break; case 40: strcat (hexchat_lang, "sv"); break; case 41: strcat (hexchat_lang, "th"); break; case 42: strcat (hexchat_lang, "uk"); break; case 43: strcat (hexchat_lang, "vi"); break; case 44: strcat (hexchat_lang, "wa"); break; default: strcat (hexchat_lang, "en_US"); break; } putenv (hexchat_lang); if (prefs.gui_one_instance && !portable_mode ()) { DWORD error; mutex = CreateMutex (NULL, TRUE, "Local\\hexchat"); error = GetLastError (); if (error == ERROR_ALREADY_EXISTS || mutex == NULL) { /* restoring the XChat window from the tray via the taskbar icon * only works correctly when X-Tray is used, but it's not a big deal * since you can only minimize XChat to tray via the taskbar if you * use X-Tray*/ if (hextray_mode ()) { /* FindWindow() doesn't support wildcards so we check all the open windows */ EnumWindows (enum_windows_impl, NULL); return 0; } else { return 1; } } } #endif #ifdef SOCKS SOCKSinit (argv[0]); #endif ret = fe_args (argc, argv); if (ret != -1) return ret; #ifdef USE_DBUS xchat_remote (); #endif #ifdef USE_LIBPROXY libproxy_factory = px_proxy_factory_new(); #endif fe_init (); xchat_init (); fe_main (); #ifdef USE_LIBPROXY px_proxy_factory_free(libproxy_factory); #endif #ifdef USE_OPENSSL if (ctx) _SSL_context_free (ctx); #endif #ifdef USE_DEBUG xchat_mem_list (); #endif #ifdef WIN32 WSACleanup (); if (prefs.gui_one_instance && !portable_mode ()) { ReleaseMutex (mutex); CloseHandle (mutex); } #endif return 0; }