static void set_up(void) {
if (p == NULL) {
p = permanent_pool = make_sub_pool(NULL);
}
init_regexp();
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_set_levels("regexp", 1, 20);
}
}
int
main(int argc, char *argv[])
{
char *p, *re;
size_t len;
Subrange *r;
void (*fn)(ulong p0, ulong p1);
/* This isn't wonderful: assume that the regexp is delimited by // */
if (argc < 2 || *(re = argv[1]) != '/' || (len = strlen(re)) < 2) {
fprintf(stderr,"Usage: x /regexp/\n");
exit(1);
}
if (re[--len] == '/')
re[len] = 0;
re++; /* skip / */
if (len == 0) {
fprintf(stderr,"null regexp\n");
exit(1);
}
if (init_regexp(re)) {
fprintf(stderr,"Invalid regexp\n");
exit(1);
}
p = strrchr(argv[0], '/');
p = p? p+1 : argv[0];
switch (*p) {
case 'x' : fn = fn_x; break;
case 'y' : fn = fn_y; break;
case 'g' : fn = fn_g; break;
case 'v' : fn = fn_v; break;
default:
fprintf(stderr,"Uknown program name!\n");
exit(1);
}
read_info(0); /* Don't reverse ranges */
Finit(&runefile, tmpfilename);
write_info();
while (r = next_range())
(*fn)(r->p0, r->p1);
exit(0);
}
int main(int argc, char *argv[]) {
pool *p;
const char *remote_name;
pr_netaddr_t *remote_addr;
conn_t *client_conn, *ctrl_conn, *data_conn;
unsigned int connect_timeout, remote_port;
struct proxy_ftp_client *ftp;
int res, timerno;
char buf[1024];
/* Seed the random number generator. */
/* XXX Use random(3) in the future? */
srand((unsigned int) (time(NULL) * getpid()));
init_pools();
init_privs();
init_log();
init_regexp();
init_inet();
init_netio();
init_netaddr();
init_fs();
init_class();
init_config();
init_stash();
pr_log_setdebuglevel(10);
log_stderr(TRUE);
pr_trace_use_stderr(TRUE);
pr_trace_set_levels("DEFAULT", 1, 20);
p = make_sub_pool(permanent_pool);
pr_pool_tag(p, "FTP Client Pool");
remote_name = "ftp.proftpd.org";
remote_addr = pr_netaddr_get_addr(p, remote_name, NULL);
if (remote_addr == NULL) {
fprintf(stderr, "Failed to get addr for '%s': %s\n", remote_name,
strerror(errno));
destroy_pool(p);
return 1;
}
fprintf(stdout, "Resolved name '%s' to IP address '%s'\n", remote_name,
pr_netaddr_get_ipstr(remote_addr));
remote_port = 21;
connect_timeout = 5;
ftp = proxy_ftp_connect(p, remote_addr, remote_port, connect_timeout, NULL);
if (ftp == NULL) {
fprintf(stderr, "Error connecting to FTP server: %s\n", strerror(errno));
destroy_pool(p);
return 1;
}
fprintf(stdout, "Successfully connected to %s:%d from %s:%d\n", remote_name,
remote_port, pr_netaddr_get_ipstr(client_conn->local_addr),
ntohs(pr_netaddr_get_port(client_conn->local_addr)));
res = proxy_ftp_disconnect(ftp);
if (res < 0) {
fprintf(stderr, "Error disconnecting from FTP server: %s\n",
strerror(errno));
destroy_pool(p);
return 1;
}
ctrl_conn = pr_inet_openrw(p, client_conn, NULL, PR_NETIO_STRM_OTHR,
-1, -1, -1, FALSE);
if (ctrl_conn == NULL) {
fprintf(stderr, "Error opening control connection: %s\n", strerror(errno));
pr_inet_close(p, client_conn);
destroy_pool(p);
return 1;
}
fprintf(stdout, "Reading response from %s:%d\n", remote_name, remote_port);
/* Read the response */
memset(buf, '\0', sizeof(buf));
/* XXX We need to write our own version of netio_telnet_gets(), with
* the buffering to handle reassembly of a full FTP response out of
* multiple TCP packets. Not sure why the existing netio_telnet_gets()
* is not sufficient. But we don't need the handling of Telnet codes
* in our reading. But DO generate the 'core.ctrl-read' event, so that
* any event listeners get a chance to process the data we've received.
* (Or maybe use 'mod_proxy.server-read', and differentiate between
* client and server reads/writes?)
*/
if (pr_netio_read(ctrl_conn->instrm, buf, sizeof(buf)-1, 5) < 0) {
fprintf(stderr, "Error reading response from server: %s\n",
strerror(errno));
} else {
fprintf(stdout, "Response: \"%s\"\n", buf);
}
/* Disconnect */
res = pr_netio_printf(ctrl_conn->outstrm, "%s\r\n", C_QUIT);
if (res < 0) {
fprintf(stderr, "Error writing command to server: %s", strerror(errno));
}
pr_inet_close(p, ctrl_conn);
pr_inet_close(p, client_conn);
destroy_pool(p);
return 0;
}
/* entry point */
int main(int ac, char **av)
{
int ret;
memset(&ctx, 0, sizeof(ctx));
/* instance handle of this module */
{
HMODULE module;
module = GetModuleHandle(NULL);
if(module == NULL) {
error_message_le("GetModuleHandle() failed");
return 1;
}
ctx.instance = (HINSTANCE)module;
}
/* initialize COM */
{
HRESULT hres;
hres = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
if(FAILED(hres)) {
error_message_hr("CoInitializeEx() failed", hres);
return 1;
}
hres = init_regexp();
if(FAILED(hres)) {
error_message_hr("init_regexp() failed", hres);
return 1;
}
}
/* create main message window */
ctx.main_window = create_main_window();
if(ctx.main_window == NULL) {
error_message_le("create_main_window() failed");
return 1;
}
/* logger */
ret = create_logger();
if(ret == 0) {
error_message_le("create_logger() failed");
return 1;
}
ctx.sprocs.hdr.api_ver = MP_OP_API_VERSION;
ctx.sprocs.hdr.type = MP_OP_TYPE_SUPPORT;
ctx.sprocs.log_printf = log_printf;
ctx.sprocs.log_s_exp = log_print_s_exp;
ctx.sprocs.log_lasterror = log_print_lasterror;
ctx.sprocs.log_hresult = log_print_hresult;
/* command line option */
{
LPWSTR *avw, file;
int acw;
avw = CommandLineToArgvW(GetCommandLineW(), &acw);
if(avw != NULL && acw >= 2) {
file = avw[1];
} else {
file = NULL;
}
/* load setting file */
load_setting(file, TRUE);
}
/* start message */
log_printf(LOG_LEVEL_NOTIFY, L"\nmouse-processor started\n");
/* main message loop */
ret = message_loop();
/* uninitialize COM */
CoUninitialize();
/* end logger */
destroy_logger();
return ret;
}
