| /* | |
| * | |
| * PACrunner - Proxy configuration daemon | |
| * | |
| * Copyright (C) 2011 Intel Corporation. All rights reserved. | |
| * | |
| * This program is free software; you can redistribute it and/or modify | |
| * it under the terms of the GNU General Public License version 2 as | |
| * published by the Free Software Foundation. | |
| * | |
| * This program is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| * GNU General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU General Public License | |
| * along with this program; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
| * | |
| */ | |
| #ifdef HAVE_CONFIG_H | |
| #include <config.h> | |
| #endif | |
| #include <unistd.h> | |
| #include <getopt.h> | |
| #include <errno.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <stdbool.h> | |
| #include <glib.h> | |
| #define DBG(fmt, arg...) do { \ | |
| printf("%s() " fmt "\n", __func__ , ## arg); \ | |
| } while (0) | |
| enum pacrunner_manual_exclude_appliance { | |
| PACRUNNER_MANUAL_EXCLUDE_POST = 0, | |
| PACRUNNER_MANUAL_EXCLUDE_PRE = 1, | |
| PACRUNNER_MANUAL_EXCLUDE_ANY = 2, | |
| }; | |
| enum pacrunner_manual_protocol { | |
| PACRUNNER_PROTOCOL_ALL = 0, | |
| PACRUNNER_PROTOCOL_HTTP = 1, | |
| PACRUNNER_PROTOCOL_HTTPS = 2, | |
| PACRUNNER_PROTOCOL_FTP = 3, | |
| PACRUNNER_PROTOCOL_SOCKS = 4, | |
| PACRUNNER_PROTOCOL_SOCKS4 = 5, | |
| PACRUNNER_PROTOCOL_SOCKS5 = 6, | |
| PACRUNNER_PROTOCOL_MAXIMUM_NUMBER = 7, | |
| PACRUNNER_PROTOCOL_UNKNOWN = 8, | |
| }; | |
| struct pacrunner_manual_exclude { | |
| enum pacrunner_manual_exclude_appliance appliance; | |
| int host_length; | |
| char *host; | |
| }; | |
| static enum pacrunner_manual_protocol get_protocol_from_string(const char *protocol) | |
| { | |
| if (!protocol) | |
| return PACRUNNER_PROTOCOL_ALL; | |
| if (g_strcmp0(protocol, "http") == 0) | |
| return PACRUNNER_PROTOCOL_HTTP; | |
| if (g_strcmp0(protocol, "https") == 0) | |
| return PACRUNNER_PROTOCOL_HTTPS; | |
| if (g_strcmp0(protocol, "ftp") == 0) | |
| return PACRUNNER_PROTOCOL_FTP; | |
| if (g_strcmp0(protocol, "socks") == 0) | |
| return PACRUNNER_PROTOCOL_SOCKS; | |
| if (g_strcmp0(protocol, "socks4") == 0) | |
| return PACRUNNER_PROTOCOL_SOCKS4; | |
| if (g_strcmp0(protocol, "socks5") == 0) | |
| return PACRUNNER_PROTOCOL_SOCKS5; | |
| return PACRUNNER_PROTOCOL_UNKNOWN; | |
| } | |
| static const char *get_protocol_to_string(enum pacrunner_manual_protocol protocol) | |
| { | |
| switch (protocol) { | |
| case PACRUNNER_PROTOCOL_ALL: | |
| return "ALL"; | |
| case PACRUNNER_PROTOCOL_HTTP: | |
| return "HTTP"; | |
| case PACRUNNER_PROTOCOL_HTTPS: | |
| return "HTTPS"; | |
| case PACRUNNER_PROTOCOL_FTP: | |
| return "FTP"; | |
| case PACRUNNER_PROTOCOL_SOCKS: | |
| return "SOCKS"; | |
| case PACRUNNER_PROTOCOL_SOCKS4: | |
| return "SOCKS4"; | |
| case PACRUNNER_PROTOCOL_SOCKS5: | |
| return "SOCKS5"; | |
| case PACRUNNER_PROTOCOL_MAXIMUM_NUMBER: | |
| case PACRUNNER_PROTOCOL_UNKNOWN: | |
| default: | |
| break; | |
| } | |
| return "UNKNOWN"; | |
| } | |
| static const char *get_appliance_to_string(enum pacrunner_manual_exclude_appliance appliance) | |
| { | |
| switch (appliance) { | |
| case PACRUNNER_MANUAL_EXCLUDE_POST: | |
| return "POST"; | |
| case PACRUNNER_MANUAL_EXCLUDE_PRE: | |
| return "PRE"; | |
| case PACRUNNER_MANUAL_EXCLUDE_ANY: | |
| return "ANY"; | |
| default: | |
| break; | |
| } | |
| return "UNKNOWN"; | |
| } | |
| static int parse_uri(char *uri, | |
| char **host, | |
| char **protocol, | |
| bool no_path, | |
| bool exclusion) | |
| { | |
| int ret = PACRUNNER_MANUAL_EXCLUDE_POST; | |
| bool proto, post_confirmed, ipv6; | |
| char *scheme, *sep, *cur; | |
| int length; | |
| long int port; | |
| proto = post_confirmed = ipv6 = false; | |
| port = -1; | |
| /** | |
| * Make sure host and protocol, if given, are properly set. | |
| */ | |
| if (host) | |
| *host = NULL; | |
| if (protocol) | |
| *protocol = NULL; | |
| /** | |
| * The parsing will actually process on a copy of given uri | |
| */ | |
| scheme = g_strdup(uri); | |
| if (!scheme) | |
| goto error; | |
| cur = scheme; | |
| /** | |
| * 1 - parsing protocol first | |
| * Note: protocol scheme is here totally ignored | |
| */ | |
| sep = strstr(cur, "://"); | |
| if (sep) { | |
| if (sep == cur) | |
| goto error; | |
| if (protocol) { | |
| *sep = '\0'; | |
| *protocol = g_strdup(cur); | |
| if (!*protocol) | |
| goto error; | |
| } | |
| cur = sep + 3; | |
| proto = true; | |
| } | |
| /** | |
| * 2 - detecting end of uri | |
| * Note: in case of server/exclusion configuration, | |
| * no path should be present | |
| */ | |
| sep = strchr(cur, '/'); | |
| if (sep) { | |
| if (exclusion || (*(sep + 1) != '\0' && | |
| no_path)) | |
| goto error; | |
| *sep = '\0'; | |
| } | |
| /** | |
| * 3 - We skip <login:password> if present | |
| * Note: exclusion rule cannot contain such authentication information | |
| */ | |
| sep = strchr(cur, '@'); | |
| if (sep) { | |
| if (exclusion) | |
| goto error; | |
| *sep = '\0'; | |
| cur = sep + 1; | |
| } | |
| /** | |
| * 4 - Are we in front of a possible IPv6 address? | |
| * Note: ipv6 format is not checked! | |
| */ | |
| sep = strchr(cur, '['); | |
| if (sep) { | |
| char *bracket; | |
| bracket = strchr(cur, ']'); | |
| if (!bracket) | |
| goto error; | |
| cur = sep; | |
| sep = strchr(bracket, ':'); | |
| ipv6 = true; | |
| } else | |
| sep = strchr(cur, ':'); | |
| /** | |
| * 5 - Checking port validity if present | |
| * Note: exclusion rule cannot embed port | |
| */ | |
| if (sep) { | |
| char *err = NULL; | |
| if (exclusion) | |
| goto error; | |
| errno = 0; | |
| port = strtol(sep+1, &err, 10); | |
| if (*err != '\0' || port <= 0 || port > USHRT_MAX || | |
| errno == ERANGE || errno == EINVAL) | |
| goto error; | |
| *sep = '\0'; | |
| } | |
| /** | |
| * 6 - We detect/trim '.'/'*' from start | |
| * Note: This is valid only for exclusion URI since it defines | |
| * its rule's appliance */ | |
| for (sep = cur; *sep != '\0' && (*sep == '*' || *sep == '.'); sep++) | |
| *sep = '\0'; | |
| if (sep != cur) { | |
| if (!exclusion) | |
| goto error; | |
| cur = sep; | |
| post_confirmed = true; | |
| } | |
| /** | |
| * 7 - Parsing host if present | |
| */ | |
| length = strlen(cur); | |
| if (length > 0) { | |
| const char *forbidden_chars; | |
| char **forbidden = NULL; | |
| /** | |
| * We first detect/trim '.'/'*' from end | |
| * Note: valid only for exclusion | |
| */ | |
| for (sep = cur + length - 1; | |
| *sep != '\0' && (*sep == '*' || *sep == '.'); sep--) | |
| *sep = '\0'; | |
| if (sep - cur + 1 != length) { | |
| if (!exclusion) | |
| goto error; | |
| length = sep - cur + 1; | |
| ret = PACRUNNER_MANUAL_EXCLUDE_PRE; | |
| if (post_confirmed) | |
| ret = PACRUNNER_MANUAL_EXCLUDE_ANY; | |
| } | |
| if ((length > 255) || (*cur == '-' || *sep == '-') || | |
| ((*cur == '\0') && (!exclusion || | |
| (exclusion && !proto)))) | |
| goto error; | |
| /** | |
| * We do not allow some characters. However we do not run | |
| * a strict check if it's an IP address which is given | |
| */ | |
| if (ipv6) | |
| forbidden_chars = "%?!,;@\\'*|<>{}()+=$&~# \""; | |
| else | |
| forbidden_chars = "%?!,;@\\'*|<>{}[]()+=$&~# \""; | |
| forbidden = g_strsplit_set(cur, forbidden_chars, -1); | |
| if (forbidden) { | |
| length = g_strv_length(forbidden); | |
| g_strfreev(forbidden); | |
| if (length > 1) | |
| goto error; | |
| } | |
| if (host && *cur != '\0') { | |
| if (port > 0) { | |
| /** | |
| * Instead of transcoding the port back | |
| * to string we just get the host:port line | |
| * from the original uri. | |
| * */ | |
| cur = uri + (cur - scheme); | |
| sep = strchr(cur, '/'); | |
| if (sep) | |
| length = sep - cur; | |
| else | |
| length = strlen(cur); | |
| *host = g_strndup(cur, length); | |
| } else | |
| *host = g_strdup(cur); | |
| if (!*host) | |
| goto error; | |
| } | |
| } else { | |
| if (!exclusion || | |
| (exclusion && !proto)) | |
| goto error; | |
| else | |
| ret = PACRUNNER_MANUAL_EXCLUDE_ANY; | |
| } | |
| g_free(scheme); | |
| return ret; | |
| error: | |
| if (protocol) { | |
| g_free(*protocol); | |
| *protocol = NULL; | |
| } | |
| g_free(scheme); | |
| return -EINVAL; | |
| } | |
| static void free_exclude(gpointer data) | |
| { | |
| struct pacrunner_manual_exclude *exclude; | |
| exclude = (struct pacrunner_manual_exclude *) data; | |
| if (!exclude) | |
| return; | |
| g_free(exclude->host); | |
| g_free(exclude); | |
| } | |
| static void __pacrunner_manual_destroy_excludes(GList **excludes) | |
| { | |
| int i; | |
| if (!excludes) | |
| return; | |
| for (i = 0; i < PACRUNNER_PROTOCOL_MAXIMUM_NUMBER; i++) | |
| g_list_free_full(excludes[i], free_exclude); | |
| g_free(excludes); | |
| } | |
| static GList **__pacrunner_manual_create_excludes(const char **excludes) | |
| { | |
| struct pacrunner_manual_exclude *exclude; | |
| char *host, *protocol; | |
| GList **result = NULL; | |
| int ret, proto; | |
| char **uri; | |
| if (!excludes) | |
| return NULL; | |
| result = g_try_malloc0(PACRUNNER_PROTOCOL_MAXIMUM_NUMBER * | |
| sizeof(GList *)); | |
| if (!result) | |
| return NULL; | |
| for (uri = (char **)excludes; *uri; uri++) { | |
| ret = parse_uri(*uri, &host, &protocol, true, true); | |
| if (ret < 0) | |
| continue; | |
| proto = get_protocol_from_string(protocol); | |
| if (proto == PACRUNNER_PROTOCOL_UNKNOWN) | |
| goto error; | |
| exclude = g_try_malloc0(sizeof( | |
| struct pacrunner_manual_exclude)); | |
| if (!exclude) | |
| goto error; | |
| exclude->appliance = ret; | |
| exclude->host = host; | |
| if (host) | |
| exclude->host_length = strlen(host); | |
| result[proto] = g_list_append(result[proto], exclude); | |
| g_free(protocol); | |
| protocol = NULL; | |
| host = NULL; | |
| } | |
| return result; | |
| error: | |
| g_free(host); | |
| g_free(protocol); | |
| __pacrunner_manual_destroy_excludes(result); | |
| return NULL; | |
| } | |
| static void __pacrunner_manual_destroy_servers(GList **servers) | |
| { | |
| int i; | |
| if (!servers) | |
| return; | |
| for (i = 0; i < PACRUNNER_PROTOCOL_MAXIMUM_NUMBER; i++) | |
| g_list_free_full(servers[i], g_free); | |
| g_free(servers); | |
| } | |
| static const char *protocol_to_prefix_string(enum pacrunner_manual_protocol proto) | |
| { | |
| switch (proto) { | |
| case PACRUNNER_PROTOCOL_ALL: | |
| case PACRUNNER_PROTOCOL_HTTP: | |
| case PACRUNNER_PROTOCOL_HTTPS: | |
| case PACRUNNER_PROTOCOL_FTP: | |
| return "PROXY"; | |
| case PACRUNNER_PROTOCOL_SOCKS: | |
| return "SOCKS"; | |
| case PACRUNNER_PROTOCOL_SOCKS4: | |
| return "SOCKS4"; | |
| case PACRUNNER_PROTOCOL_SOCKS5: | |
| return "SOCKS5"; | |
| case PACRUNNER_PROTOCOL_MAXIMUM_NUMBER: | |
| case PACRUNNER_PROTOCOL_UNKNOWN: | |
| break; | |
| }; | |
| return ""; | |
| } | |
| static GList *append_proxy(GList *list, | |
| enum pacrunner_manual_protocol proto, char *host) | |
| { | |
| char *proxy; | |
| proxy = g_strdup_printf("%s %s", | |
| protocol_to_prefix_string(proto), host); | |
| if (!proxy) | |
| return list; | |
| return g_list_append(list, proxy); | |
| } | |
| static GList **__pacrunner_manual_create_servers(const char **servers) | |
| { | |
| char *host, *protocol; | |
| GList **result; | |
| char **uri; | |
| int proto; | |
| int ret; | |
| if (!servers) | |
| return NULL; | |
| result = g_try_malloc0(PACRUNNER_PROTOCOL_MAXIMUM_NUMBER * | |
| sizeof(GList *)); | |
| if (!result) | |
| return NULL; | |
| for (uri = (char **)servers; *uri; uri++) { | |
| ret = parse_uri(*uri, &host, &protocol, true, false); | |
| if (ret < 0) | |
| continue; | |
| proto = get_protocol_from_string(protocol); | |
| if (proto == PACRUNNER_PROTOCOL_UNKNOWN) | |
| goto error; | |
| result[proto] = append_proxy(result[proto], proto, host); | |
| if (proto == PACRUNNER_PROTOCOL_SOCKS) { | |
| result[PACRUNNER_PROTOCOL_SOCKS4] = append_proxy( | |
| result[PACRUNNER_PROTOCOL_SOCKS4], | |
| PACRUNNER_PROTOCOL_SOCKS4, host); | |
| result[PACRUNNER_PROTOCOL_SOCKS5] = append_proxy( | |
| result[PACRUNNER_PROTOCOL_SOCKS5], | |
| PACRUNNER_PROTOCOL_SOCKS5, host); | |
| } | |
| g_free(protocol); | |
| g_free(host); | |
| } | |
| return result; | |
| error: | |
| g_free(host); | |
| g_free(protocol); | |
| __pacrunner_manual_destroy_servers(result); | |
| return NULL; | |
| } | |
| static bool is_exclusion_matching(GList *excludes_list, | |
| const char *host) | |
| { | |
| struct pacrunner_manual_exclude *exclusion; | |
| GList *excludes = NULL; | |
| char *cursor; | |
| for (excludes = excludes_list; excludes; | |
| excludes = excludes->next) { | |
| exclusion = (struct pacrunner_manual_exclude *) excludes->data; | |
| if (!exclusion) | |
| continue; | |
| cursor = NULL; | |
| if (exclusion->host) | |
| cursor = strstr(host, exclusion->host); | |
| switch (exclusion->appliance) { | |
| case PACRUNNER_MANUAL_EXCLUDE_POST: | |
| if (!cursor) | |
| break; | |
| if ((int)strlen(cursor) < exclusion->host_length) | |
| break; | |
| if (*(cursor + exclusion->host_length) == '\0') | |
| return true; | |
| break; | |
| case PACRUNNER_MANUAL_EXCLUDE_PRE: | |
| if (cursor == host) | |
| return true; | |
| break; | |
| case PACRUNNER_MANUAL_EXCLUDE_ANY: | |
| if (exclusion->host) { | |
| if (cursor) | |
| return true; | |
| else | |
| break; | |
| } | |
| return true; | |
| default: | |
| break; | |
| } | |
| } | |
| return false; | |
| } | |
| static bool is_url_excluded(GList **excludes, | |
| const char *host, | |
| enum pacrunner_manual_protocol proto) | |
| { | |
| if (!excludes) | |
| return false; | |
| if (excludes[PACRUNNER_PROTOCOL_ALL]) | |
| if (is_exclusion_matching(excludes[PACRUNNER_PROTOCOL_ALL], | |
| host)) | |
| return true; | |
| if (proto == PACRUNNER_PROTOCOL_UNKNOWN) | |
| return false; | |
| if (excludes[proto]) | |
| if (is_exclusion_matching(excludes[proto], host)) | |
| return true; | |
| return false; | |
| } | |
| static inline char *append_server(char *prev_result, const char *proxy) | |
| { | |
| char *result; | |
| if (!prev_result) | |
| return g_strdup(proxy); | |
| result = g_strjoin("; ", prev_result, proxy, NULL); | |
| if (!result) | |
| return prev_result; | |
| g_free(prev_result); | |
| return result; | |
| } | |
| static inline char *append_servers_to_proxy_string(char *prev_result, | |
| GList *proxies) | |
| { | |
| char *result = prev_result; | |
| GList *list, *prev; | |
| prev = NULL; | |
| for (list = proxies; list && list != prev; | |
| prev = list, list = list->next) | |
| result = append_server(result, (const char *) list->data); | |
| return result; | |
| } | |
| static char *generate_proxy_string(GList **servers, | |
| enum pacrunner_manual_protocol proto) | |
| { | |
| enum pacrunner_manual_protocol i; | |
| char *result = NULL; | |
| /* if the protocol is known, we will prefer to set same | |
| * protocol-based proxies first, if any... */ | |
| if (proto >= PACRUNNER_PROTOCOL_HTTP && | |
| proto < PACRUNNER_PROTOCOL_MAXIMUM_NUMBER) { | |
| if (servers[proto]) | |
| result = append_servers_to_proxy_string(result, | |
| servers[proto]); | |
| if (proto == PACRUNNER_PROTOCOL_SOCKS) { | |
| if (servers[PACRUNNER_PROTOCOL_SOCKS4]) | |
| result = append_servers_to_proxy_string(result, | |
| servers[PACRUNNER_PROTOCOL_SOCKS4]); | |
| if (servers[PACRUNNER_PROTOCOL_SOCKS5]) | |
| result = append_servers_to_proxy_string(result, | |
| servers[PACRUNNER_PROTOCOL_SOCKS5]); | |
| } | |
| } | |
| /* And/or we add the rest in the list */ | |
| for (i = 0; i < PACRUNNER_PROTOCOL_MAXIMUM_NUMBER; i++) { | |
| if (i == proto || (proto == PACRUNNER_PROTOCOL_SOCKS && | |
| (i == PACRUNNER_PROTOCOL_SOCKS4 || | |
| i == PACRUNNER_PROTOCOL_SOCKS5))) | |
| continue; | |
| if (servers[i]) | |
| result = append_servers_to_proxy_string(result, | |
| servers[i]); | |
| } | |
| return result; | |
| } | |
| static char *__pacrunner_manual_execute(const char *url, | |
| GList **servers, | |
| GList **excludes) | |
| { | |
| char *protocol = NULL; | |
| char *result = NULL; | |
| char *host = NULL; | |
| int proto; | |
| if (!servers) | |
| return NULL; | |
| if (parse_uri((char *)url, &host, &protocol, false, false) < 0) | |
| goto direct; | |
| proto = get_protocol_from_string(protocol); | |
| if (is_url_excluded(excludes, host, proto)) | |
| goto direct; | |
| result = generate_proxy_string(servers, proto); | |
| direct: | |
| g_free(protocol); | |
| g_free(host); | |
| return result; | |
| } | |
| static void dump_proxy_exclusion(gpointer data, gpointer user_data) | |
| { | |
| struct pacrunner_manual_exclude *exclusion; | |
| exclusion = (struct pacrunner_manual_exclude *) data; | |
| if (!exclusion) | |
| return; | |
| printf("\tappliance: %s\n", | |
| get_appliance_to_string(exclusion->appliance)); | |
| printf("\thost: %s (%d)\n", exclusion->host, exclusion->host_length); | |
| } | |
| static void dump_excludes(GList **excludes) | |
| { | |
| int i; | |
| printf("EXCLUDES:\n"); | |
| if (!excludes) { | |
| printf("\tNO EXCLUDES\n"); | |
| return; | |
| } | |
| for (i = 0; i < PACRUNNER_PROTOCOL_MAXIMUM_NUMBER; i++) { | |
| printf("Protocol: %s\n", get_protocol_to_string(i)); | |
| if (!excludes[i]) { | |
| printf("\tNONE\n"); | |
| continue; | |
| } | |
| g_list_foreach(excludes[i], dump_proxy_exclusion, NULL); | |
| printf("\n"); | |
| } | |
| } | |
| static void dump_proxy_server(gpointer data, gpointer user_data) | |
| { | |
| printf("\t%s\n", (char *)data); | |
| } | |
| static void dump_servers(GList **servers) | |
| { | |
| int i; | |
| printf("SERVERS:\n"); | |
| if (!servers) { | |
| printf("\tNO SERVERS\n"); | |
| return; | |
| } | |
| for (i = 0; i < PACRUNNER_PROTOCOL_MAXIMUM_NUMBER; i++) { | |
| printf("Protocol: %s\n", get_protocol_to_string(i)); | |
| if (!servers[i]) { | |
| printf("\tNONE\n"); | |
| continue; | |
| } | |
| g_list_foreach(servers[i], dump_proxy_server, NULL); | |
| printf("\n"); | |
| } | |
| } | |
| static void print_help(void) | |
| { | |
| printf("Manual Proxy configuration test tool\n" | |
| "Usage:\n" | |
| "-e,--excludes <list>: provides an exclusion list (optional)\n" | |
| "-h,--help : prints this help message\n" | |
| "-s,--servers <list>: provides the proxy server(s) (mandatory)\n" | |
| "-t,--test <list>: provides the URLs to test (mandatory)\n" | |
| "list should be made like \"elt1,elt2\" and so on\n" | |
| "\n" | |
| "Servers example:\n" | |
| "http://stuff.com -> http proxy\n" | |
| "stuff.com -> general proxy\n" | |
| "ftp://foo.org:4578 -> ftp proxy, with specific port\n" | |
| "\n" | |
| "Exclusion example:\n" | |
| "If a uri matches an exclusion rule, it will not be proxied\n" | |
| "port number is not allowed in exclusion rules\n" | |
| "'*' is not allowed for protocols\n" | |
| "stuff*foo is not allowed\n" | |
| "http:// -> all http\n" | |
| "http://*foo* -> all http containing foo\n" | |
| "*com -> all host ending with com\n" | |
| "ftp://stuff* -> all ftp starting with stuff\n"); | |
| } | |
| static struct option long_options[] = { | |
| {"excludes", 1, 0, 'e'}, | |
| {"help", 0, 0, 'h'}, | |
| {"servers", 1, 0, 's'}, | |
| {"test", 1, 0, 't'}, | |
| {NULL, 0, 0, 0 } | |
| }; | |
| static const char *short_options = "e:hs:t:"; | |
| int main(int argc, char *argv[]) | |
| { | |
| char **excludes_list, **servers_list, **tests_list; | |
| GList **excludes = NULL; | |
| GList **servers = NULL; | |
| int opt, option_index; | |
| char **url; | |
| excludes_list = NULL; | |
| servers_list = NULL; | |
| tests_list = NULL; | |
| option_index = 0; | |
| while ((opt = getopt_long(argc, argv, short_options, | |
| long_options, &option_index)) != -1) { | |
| switch (opt) { | |
| case 'e': | |
| excludes_list = g_strsplit(optarg, ",", 0); | |
| if (!excludes_list) | |
| exit(EXIT_FAILURE); | |
| break; | |
| case 'h': | |
| print_help(); | |
| exit(EXIT_SUCCESS); | |
| break; | |
| case 's': | |
| servers_list = g_strsplit(optarg, ",", 0); | |
| if (!servers_list) | |
| exit(EXIT_FAILURE); | |
| break; | |
| case 't': | |
| tests_list = g_strsplit(optarg, ",", 0); | |
| if (!tests_list) | |
| exit(EXIT_FAILURE); | |
| break; | |
| case '?': | |
| break; | |
| default: | |
| printf("Unknown option\n" | |
| "please see --help for more informations\n"); | |
| exit(EXIT_FAILURE); | |
| break; | |
| } | |
| } | |
| if (!servers_list || !tests_list) { | |
| printf("You must provide server(s) and test(s) options\n"); | |
| exit(EXIT_FAILURE); | |
| } | |
| servers = __pacrunner_manual_create_servers((const char **) | |
| servers_list); | |
| if (!servers) | |
| exit(EXIT_FAILURE); | |
| excludes = __pacrunner_manual_create_excludes((const char **) | |
| excludes_list); | |
| dump_excludes(excludes); | |
| dump_servers(servers); | |
| g_strfreev(excludes_list); | |
| g_strfreev(servers_list); | |
| for (url = tests_list; *url; url++) { | |
| char *proxy; | |
| printf("Url: %s -> ", *url); | |
| proxy = __pacrunner_manual_execute(*url, servers, excludes); | |
| if (!proxy) | |
| printf("DIRECT\n"); | |
| else | |
| printf("%s\n", proxy); | |
| } | |
| g_strfreev(tests_list); | |
| __pacrunner_manual_destroy_excludes(excludes); | |
| __pacrunner_manual_destroy_servers(servers); | |
| return 0; | |
| } |