/* input function: DCC GET received data */
static void sig_dccget_receive(GET_DCC_REC *dcc)
{
char buffer[512];
int ret;
for (;;) {
ret = net_receive(dcc->handle, buffer, sizeof(buffer));
if (ret == 0) break;
if (ret < 0) {
/* socket closed - transmit complete,
or other side died.. */
dcc_close(DCC(dcc));
return;
}
if (write(dcc->fhandle, buffer, ret) != ret) {
/* most probably out of disk space */
signal_emit("dcc error write", 2,
dcc, g_strerror(errno));
dcc_close(DCC(dcc));
return;
}
dcc->transfd += ret;
}
/* send number of total bytes received */
if (dcc->count_pos <= 0)
dcc_get_send_received(dcc);
signal_emit("dcc transfer update", 1, dcc);
}
/* input function: DCC SEND - received some data */
static void dcc_send_read_size(SEND_DCC_REC *dcc)
{
guint32 bytes;
int ret;
ret = net_receive(dcc->handle, dcc->count_buf+dcc->count_pos,
4-dcc->count_pos);
if (ret == -1) {
dcc_close(DCC(dcc));
return;
}
dcc->count_pos += ret;
if (dcc->count_pos != 4)
return;
bytes = ntohl(*((guint32 *) dcc->count_buf));
dcc->count_pos = 0;
if (dcc->waitforend && bytes == (dcc->transfd & 0xffffffff)) {
/* file is sent */
dcc->gotalldata = TRUE;
dcc_close(DCC(dcc));
}
}
/* input function: DCC SERVER received some data.. */
static void dcc_server_input(SERVER_DCC_REC *dcc)
{
char tmpbuf[512], *str;
int recvlen, ret;
g_return_if_fail(IS_DCC_SERVER(dcc));
do {
recvlen = net_receive(dcc->handle, tmpbuf, sizeof(tmpbuf));
ret = line_split(tmpbuf, recvlen, &str, &dcc->readbuf);
if (ret == -1) {
/* connection lost */
dcc_close(DCC(dcc));
break;
}
if (ret > 0) {
dcc->transfd += ret;
signal_emit("dcc server message", 2, dcc, str);
}
if (dcc->connection_established) {
/* We set handle to NULL first because the new (chat/get) is using the same */
/* handle and we don't want dcc_close to disconnect it.*/
dcc->handle = NULL;
dcc_close(DCC(dcc));
break;
}
} while (ret > 0);
}
/* Resume a DCC GET */
static void dcc_send_resume(GET_DCC_REC *dcc)
{
off_t pos;
char *str;
g_return_if_fail(dcc != NULL);
dcc->file = dcc_get_download_path(dcc->arg);
dcc->fhandle = open(dcc->file, O_WRONLY);
if (dcc->fhandle == -1) {
signal_emit("dcc error file open", 3, dcc->nick, dcc->file,
GINT_TO_POINTER(errno));
return;
}
dcc->get_type = DCC_GET_RESUME;
pos = lseek(dcc->fhandle, 0, SEEK_END);
dcc->transfd = pos == (off_t)-1 ? 0 : (unsigned long) pos;
dcc->skipped = dcc->transfd;
if (dcc->skipped == dcc->size) {
/* already received whole file */
dcc->starttime = time(NULL);
dcc_reject(DCC(dcc), NULL);
} else {
str = g_strdup_printf(dcc->file_quoted ?
"DCC RESUME \"%s\" %d %lu" :
"DCC RESUME %s %d %lu",
dcc->arg, dcc->port, dcc->transfd);
dcc_ctcp_message(dcc->server, dcc->nick,
dcc->chat, FALSE, str);
g_free(str);
}
}
void dcc_get_connect(GET_DCC_REC *dcc)
{
if (dcc->get_type == DCC_GET_DEFAULT) {
dcc->get_type = settings_get_bool("dcc_autorename") ?
DCC_GET_RENAME : DCC_GET_OVERWRITE;
}
if (dcc->from_dccserver) {
sig_dccget_connected(dcc);
return;
}
dcc->handle = dcc_connect_ip(&dcc->addr, dcc->port);
if (dcc->handle != NULL) {
dcc->tagconn =
g_input_add(dcc->handle,
G_INPUT_WRITE | G_INPUT_READ,
(GInputFunction) sig_dccget_connected,
dcc);
} else {
/* error connecting */
signal_emit("dcc error connect", 1, dcc);
dcc_destroy(DCC(dcc));
}
}
/* input function: DCC CHAT received some data.. */
void dcc_chat_input(CHAT_DCC_REC *dcc)
{
char *str;
int ret;
g_return_if_fail(IS_DCC_CHAT(dcc));
do {
ret = net_sendbuffer_receive_line(dcc->sendbuf, &str, 1);
if (ret == -1) {
/* connection lost */
dcc->connection_lost = TRUE;
dcc_close(DCC(dcc));
break;
}
if (ret > 0) {
char *recoded;
dcc->transfd += ret;
recoded = recode_in(SERVER(dcc->server), str, dcc->nick);
signal_emit("dcc chat message", 2, dcc, recoded);
g_free(recoded);
}
} while (ret > 0);
}
/* Resume a DCC GET */
static void dcc_send_resume(GET_DCC_REC *dcc)
{
char *str;
g_return_if_fail(dcc != NULL);
dcc->file = dcc_get_download_path(dcc->arg);
dcc->fhandle = open(dcc->file, O_WRONLY);
if (dcc->fhandle == -1) {
signal_emit("dcc error file not found", 2, dcc, dcc->file);
return;
}
dcc->get_type = DCC_GET_RESUME;
dcc->transfd = lseek(dcc->fhandle, 0, SEEK_END);
if (dcc->transfd < 0) dcc->transfd = 0;
dcc->skipped = dcc->transfd;
if (dcc->skipped == dcc->size) {
/* already received whole file */
dcc->starttime = time(NULL);
dcc_reject(DCC(dcc), NULL);
} else {
str = g_strdup_printf(dcc->file_quoted ?
"DCC RESUME \"%s\" %d %lu" :
"DCC RESUME %s %d %lu",
dcc->arg, dcc->port, dcc->transfd);
dcc_ctcp_message(dcc->server, dcc->nick,
dcc->chat, FALSE, str);
g_free(str);
}
}
static int dcc_resume_file_check(FILE_DCC_REC *dcc, IRC_SERVER_REC *server,
uoff_t size)
{
if (size >= dcc->size) {
/* whole file sent */
dcc->starttime = time(NULL);
dcc_reject(DCC(dcc), server);
} else if (lseek(dcc->fhandle, (off_t)size, SEEK_SET) != (off_t)size) {
/* error */
dcc_reject(DCC(dcc), server);
} else {
dcc->transfd = dcc->skipped = size;
return TRUE;
}
return FALSE;
}
static int dcc_resume_file_check(FILE_DCC_REC *dcc, IRC_SERVER_REC *server,
unsigned long size)
{
if (size >= dcc->size) {
/* whole file sent */
dcc->starttime = time(NULL);
dcc_reject(DCC(dcc), server);
} else if (lseek(dcc->fhandle, size, SEEK_SET) != (long)size) {
/* error, or trying to seek after end of file */
dcc_reject(DCC(dcc), server);
} else {
dcc->transfd = dcc->skipped = size;
return TRUE;
}
return FALSE;
}
/* CTCP: DCC SEND */
static void ctcp_msg_dcc_send(IRC_SERVER_REC *server, const char *data,
const char *nick, const char *addr,
const char *target, CHAT_DCC_REC *chat)
{
GET_DCC_REC *dcc;
IPADDR ip;
char **params, *fname;
int paramcount, fileparams;
int port, len, quoted = FALSE;
long size;
/* SEND <file name> <address> <port> <size> [...] */
params = g_strsplit(data, " ", -1);
paramcount = strarray_length(params);
if (paramcount < 4) {
signal_emit("dcc error ctcp", 5, "SEND", data,
nick, addr, target);
g_strfreev(params);
return;
}
fileparams = get_file_params_count(params, paramcount);
dcc_str2ip(params[fileparams], &ip);
port = atoi(params[fileparams+1]);
size = atol(params[fileparams+2]);
params[fileparams] = NULL;
fname = g_strjoinv(" ", params);
g_strfreev(params);
len = strlen(fname);
if (len > 1 && *fname == '"' && fname[len-1] == '"') {
/* "file name" - MIRC sends filenames with spaces like this */
fname[len-1] = '\0';
g_memmove(fname, fname+1, len);
quoted = TRUE;
}
dcc = DCC_GET(dcc_find_request(DCC_GET_TYPE, nick, fname));
if (dcc != NULL) {
/* same DCC request offered again, remove the old one */
dcc_destroy(DCC(dcc));
}
dcc = dcc_get_create(server, chat, nick, fname);
dcc->target = g_strdup(target);
memcpy(&dcc->addr, &ip, sizeof(ip));
net_ip2host(&dcc->addr, dcc->addrstr);
dcc->port = port;
dcc->size = size;
dcc->file_quoted = quoted;
signal_emit("dcc request", 2, dcc, addr);
g_free(fname);
}
/* callback: net_connect() finished for DCC GET */
static void sig_dccget_connected(GET_DCC_REC *dcc)
{
struct stat statbuf;
char *fname;
if (net_geterror(dcc->handle) != 0) {
/* error connecting */
signal_emit("dcc error connect", 1, dcc);
dcc_destroy(DCC(dcc));
return;
}
g_source_remove(dcc->tagconn);
g_free_not_null(dcc->file);
dcc->file = dcc_get_download_path(dcc->arg);
/* if some plugin wants to change the file name/path here.. */
signal_emit("dcc get receive", 1, dcc);
if (stat(dcc->file, &statbuf) == 0 &&
dcc->get_type == DCC_GET_RENAME) {
/* file exists, rename.. */
fname = dcc_get_rename_file(dcc->file);
g_free(dcc->file);
dcc->file = fname;
}
if (dcc->get_type != DCC_GET_RESUME) {
dcc->fhandle = open(dcc->file, O_WRONLY | O_TRUNC | O_CREAT,
dcc_file_create_mode);
if (dcc->fhandle == -1) {
signal_emit("dcc error file create", 2,
dcc, dcc->file);
dcc_destroy(DCC(dcc));
return;
}
}
dcc->starttime = time(NULL);
dcc->tagread = g_input_add(dcc->handle, G_INPUT_READ,
(GInputFunction) sig_dccget_receive, dcc);
signal_emit("dcc connected", 1, dcc);
}
static GET_DCC_REC *dcc_get_create(IRC_SERVER_REC *server, CHAT_DCC_REC *chat,
const char *nick, const char *arg)
{
GET_DCC_REC *dcc;
dcc = g_new0(GET_DCC_REC, 1);
dcc->orig_type = module_get_uniq_id_str("DCC", "SEND");
dcc->type = module_get_uniq_id_str("DCC", "GET");
dcc->fhandle = -1;
dcc_init_rec(DCC(dcc), server, chat, nick, arg);
return dcc;
}
static void sig_query_destroyed(QUERY_REC *query)
{
CHAT_DCC_REC *dcc;
if (*query->name != '=')
return;
dcc = dcc_chat_find_id(query->name+1);
if (dcc != NULL && !dcc->destroyed) {
/* DCC query window closed, close the dcc chat too. */
dcc_close(DCC(dcc));
}
}
CHAT_DCC_REC *dcc_chat_create(IRC_SERVER_REC *server,
CHAT_DCC_REC *chat,
const char *nick, const char *arg)
{
CHAT_DCC_REC *dcc;
dcc = g_new0(CHAT_DCC_REC, 1);
dcc->orig_type = dcc->type = DCC_CHAT_TYPE;
dcc->mirc_ctcp = settings_get_bool("dcc_mirc_ctcp");
dcc->id = dcc_chat_get_new_id(nick);
dcc_init_rec(DCC(dcc), server, chat, nick, arg);
return dcc;
}
/* DCC CLOSE CHAT <nick> - check only from chat_ids in open DCC chats,
the default handler will check from DCC chat requests */
static void cmd_dcc_close(char *data, SERVER_REC *server)
{
GSList *tmp, *next;
char *nick;
void *free_arg;
int found;
g_return_if_fail(data != NULL);
if (g_ascii_strncasecmp(data, "CHAT ", 5) != 0 ||
!cmd_get_params(data, &free_arg, 2, NULL, &nick))
return;
if (*nick == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
found = FALSE;
for (tmp = dcc_conns; tmp != NULL; tmp = next) {
CHAT_DCC_REC *dcc = tmp->data;
next = tmp->next;
if (IS_DCC_CHAT(dcc) && dcc->id != NULL &&
g_ascii_strcasecmp(dcc->id, nick) == 0) {
found = TRUE;
if (!dcc_is_connected(dcc) && IS_IRC_SERVER(server))
dcc_reject(DCC(dcc), IRC_SERVER(server));
else {
/* don't send DCC REJECT after DCC chat
is already open */
dcc_close(DCC(dcc));
}
}
}
if (found) signal_stop();
cmd_params_free(free_arg);
}
static void dcc_chat_connect(CHAT_DCC_REC *dcc)
{
g_return_if_fail(IS_DCC_CHAT(dcc));
if (dcc->addrstr[0] == '\0' ||
dcc->starttime != 0 || dcc->handle != NULL) {
/* already sent a chat request / already chatting */
return;
}
dcc->handle = dcc_connect_ip(&dcc->addr, dcc->port);
if (dcc->handle != NULL) {
dcc->tagconn = g_input_add(dcc->handle,
G_INPUT_WRITE | G_INPUT_READ,
(GInputFunction) sig_chat_connected, dcc);
} else {
/* error connecting */
signal_emit("dcc error connect", 1, dcc);
dcc_destroy(DCC(dcc));
}
}
CHAT_DCC_REC *dcc_chat_create(IRC_SERVER_REC *server,
CHAT_DCC_REC *chat,
const char *nick, const char *arg)
{
CHAT_DCC_REC *dcc;
dcc = g_new0(CHAT_DCC_REC, 1);
dcc->orig_type = dcc->type = DCC_CHAT_TYPE;
dcc->mirc_ctcp = settings_get_bool("dcc_mirc_ctcp");
dcc->id = dcc_chat_get_new_id(nick);
dcc_init_rec(DCC(dcc), server, chat, nick, arg);
if (dcc->module_data == NULL) {
/* failed to successfully init; TODO: change init_rec API */
g_free(dcc->id);
g_free(dcc);
return NULL;
}
return dcc;
}
static int crypt_all(int *pcount, struct db_salt *salt)
{
const int count = *pcount ;
int salt_len;
#ifdef _DEBUG
struct timeval startc, endc, startg, endg ;
gettimeofday(&startc, NULL) ;
#endif
UTF16 salt_host[MAX_SALT_LENGTH + 1];
memset(salt_host, 0, sizeof(salt_host));
/* Proper Unicode conversion from UTF-8 or codepage */
salt_len = enc_to_utf16(salt_host,
MAX_SALT_LENGTH,
(UTF8*)currentsalt.username,
currentsalt.length);
/* Handle truncation */
if (salt_len < 0)
salt_len = strlen16(salt_host);
DCC((unsigned char*)salt_host, salt_len, dcc_hash_host, count) ;
if(salt_len > 22)
pbkdf2_iter0(dcc_hash_host,(unsigned char*)salt_host, (salt_len << 1) , count);
#ifdef _DEBUG
gettimeofday(&startg, NULL) ;
#endif
///defined in common_opencl_pbkdf2.c. Details provided in common_opencl_pbkdf2.h
pbkdf2_divide_work(dcc_hash_host, (cl_uint*)salt_host, salt_len, currentsalt.iter_cnt, dcc2_hash_host, hmac_sha1_out, count) ;
#ifdef _DEBUG
gettimeofday(&endg, NULL);
gettimeofday(&endc, NULL);
fprintf(stderr, "\nGPU:%f ",(endg.tv_sec - startg.tv_sec) + (double)(endg.tv_usec - startg.tv_usec) / 1000000.000) ;
fprintf(stderr, "CPU:%f ",(endc.tv_sec - startc.tv_sec) + (double)(endc.tv_usec - startc.tv_usec) / 1000000.000 - ((endg.tv_sec - startg.tv_sec) + (double)(endg.tv_usec - startg.tv_usec) / 1000000.000)) ;
#endif
return count ;
}
/* callback: DCC CHAT - connect finished */
static void sig_chat_connected(CHAT_DCC_REC *dcc)
{
g_return_if_fail(IS_DCC_CHAT(dcc));
if (net_geterror(dcc->handle) != 0) {
/* error connecting */
signal_emit("dcc error connect", 1, dcc);
dcc_destroy(DCC(dcc));
return;
}
/* connect ok. */
g_source_remove(dcc->tagconn);
dcc->tagconn = -1;
dcc->starttime = time(NULL);
dcc->sendbuf = net_sendbuffer_create(dcc->handle, 0);
dcc->tagread = g_input_add(dcc->handle, G_INPUT_READ,
(GInputFunction) dcc_chat_input, dcc);
signal_emit("dcc connected", 1, dcc);
}
/* DCC CLOSE SERVER <port> */
static void cmd_dcc_close(char *data, SERVER_REC *server)
{
GSList *tmp, *next;
char *port_str;
void *free_arg;
int found, port;
g_return_if_fail(data != NULL);
if (g_strncasecmp(data, "SERVER ", 7) != 0 ||
!cmd_get_params(data, &free_arg, 2, NULL, &port_str)) {
return;
}
if (*port_str == '\0') {
cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
}
port = atoi(port_str);
found = FALSE;
for (tmp = dcc_conns; tmp != NULL; tmp = next) {
SERVER_DCC_REC *dcc = tmp->data;
next = tmp->next;
if (IS_DCC_SERVER(dcc) && dcc->port == port) {
found = TRUE;
dcc_close(DCC(dcc));
}
}
if (found) {
signal_stop();
}
cmd_params_free(free_arg);
}
/* callback: net_connect() finished for DCC GET */
void sig_dccget_connected(GET_DCC_REC *dcc)
{
struct stat statbuf;
char *fname, *tempfname, *str;
int ret, ret_errno, temphandle, old_umask;
if (!dcc->from_dccserver) {
if (net_geterror(dcc->handle) != 0) {
/* error connecting */
signal_emit("dcc error connect", 1, dcc);
dcc_destroy(DCC(dcc));
return;
}
g_source_remove(dcc->tagconn);
dcc->tagconn = -1;
}
g_free_not_null(dcc->file);
dcc->file = dcc_get_download_path(dcc->arg);
/* if some plugin wants to change the file name/path here.. */
signal_emit("dcc get receive", 1, dcc);
if (stat(dcc->file, &statbuf) == 0 &&
dcc->get_type == DCC_GET_RENAME) {
/* file exists, rename.. */
fname = dcc_get_rename_file(dcc->file);
g_free(dcc->file);
dcc->file = fname;
}
if (dcc->get_type != DCC_GET_RESUME) {
int dcc_file_create_mode = octal2dec(settings_get_int("dcc_file_create_mode"));
/* we want to overwrite the file, remove it here.
if it gets created after this, we'll fail. */
unlink(dcc->file);
/* just to make sure we won't run into race conditions
if download_path is in some global temp directory */
tempfname = g_strconcat(dcc->file, ".XXXXXX", NULL);
old_umask = umask(0077);
temphandle = mkstemp(tempfname);
umask(old_umask);
if (temphandle == -1)
ret = -1;
else
ret = fchmod(temphandle, dcc_file_create_mode);
close(temphandle);
if (ret != -1) {
ret = link(tempfname, dcc->file);
if (ret == -1 &&
/* Linux */
(errno == EPERM ||
/* FUSE */
errno == ENOSYS ||
/* BSD */
errno == EOPNOTSUPP)) {
/* hard links aren't supported - some people
want to download stuff to FAT/NTFS/etc
partitions, so fallback to rename() */
ret = rename(tempfname, dcc->file);
}
}
/* if ret = 0, we're the file owner now */
dcc->fhandle = ret == -1 ? -1 :
open(dcc->file, O_WRONLY | O_TRUNC);
/* close/remove the temp file */
ret_errno = errno;
unlink(tempfname);
g_free(tempfname);
if (dcc->fhandle == -1) {
signal_emit("dcc error file create", 3,
dcc, dcc->file, g_strerror(ret_errno));
dcc_destroy(DCC(dcc));
return;
}
}
dcc->starttime = time(NULL);
if (dcc->size == 0) {
dcc_close(DCC(dcc));
return;
}
dcc->tagread = g_input_add(dcc->handle, G_INPUT_READ,
(GInputFunction) sig_dccget_receive, dcc);
signal_emit("dcc connected", 1, dcc);
if (dcc->from_dccserver) {
str = g_strdup_printf("121 %s %d\n",
dcc->server ? dcc->server->nick : "??", 0);
net_transmit(dcc->handle, str, strlen(str));
}
}
/* SYNTAX: DCC CHAT [-passive] [<nick>] */
static void cmd_dcc_chat(const char *data, IRC_SERVER_REC *server)
{
void *free_arg;
CHAT_DCC_REC *dcc;
IPADDR own_ip;
GIOChannel *handle;
GHashTable *optlist;
int p_id;
char *nick, host[MAX_IP_LEN];
int port;
g_return_if_fail(data != NULL);
if (!cmd_get_params(data, &free_arg, 1 | PARAM_FLAG_OPTIONS,
"dcc chat", &optlist, &nick))
return;
if (*nick == '\0') {
dcc = DCC_CHAT(dcc_find_request_latest(DCC_CHAT_TYPE));
if (dcc != NULL) {
if (!dcc_is_passive(dcc))
dcc_chat_connect(dcc);
else
dcc_chat_passive(dcc);
}
cmd_params_free(free_arg);
return;
}
dcc = dcc_chat_find_id(nick);
if (dcc != NULL && dcc_is_waiting_user(dcc)) {
if (!dcc_is_passive(dcc)) {
/* found from dcc chat requests,
we're the connecting side */
dcc_chat_connect(dcc);
} else {
/* We are accepting a passive DCC CHAT. */
dcc_chat_passive(dcc);
}
cmd_params_free(free_arg);
return;
}
if (dcc != NULL && dcc_is_listening(dcc) &&
dcc->server == server) {
/* sending request again even while old request is
still waiting, remove it. */
dcc_destroy(DCC(dcc));
}
if (!IS_IRC_SERVER(server) || !server->connected)
cmd_param_error(CMDERR_NOT_CONNECTED);
dcc = dcc_chat_create(server, NULL, nick, "chat");
if (dcc == NULL) {
cmd_params_free(free_arg);
g_warn_if_reached();
return;
}
if (g_hash_table_lookup(optlist, "passive") == NULL) {
/* Standard DCC CHAT... let's listen for incoming connections */
handle = dcc_listen(net_sendbuffer_handle(server->handle),
&own_ip, &port);
if (handle == NULL)
cmd_param_error(CMDERR_ERRNO);
dcc->handle = handle;
dcc->tagconn =
g_input_add(dcc->handle, G_INPUT_READ,
(GInputFunction) dcc_chat_listen, dcc);
/* send the chat request */
signal_emit("dcc request send", 1, dcc);
dcc_ip2str(&own_ip, host);
irc_send_cmdv(server, "PRIVMSG %s :\001DCC CHAT CHAT %s %d\001",
nick, host, port);
} else {
/* Passive protocol... we want the other side to listen */
/* send the chat request */
dcc->port = 0;
signal_emit("dcc request send", 1, dcc);
/* generate a random id */
p_id = rand() % 64;
dcc->pasv_id = p_id;
/* 16843009 is the long format of 1.1.1.1, we use a fake IP
since the other side shouldn't care of it: they will send
the address for us to connect to in the reply */
irc_send_cmdv(server,
"PRIVMSG %s :\001DCC CHAT CHAT 16843009 0 %d\001",
nick, p_id);
}
cmd_params_free(free_arg);
}
int main(int argc, char* argv[])
{
// first param is dimension
// second param is number of points
int d = 4;
int n = 100;
int range = 100;
unsigned which(255);
if (argc > 1 && std::string(argv[1])=="-h") {
std::cout << "usage: " << argv[0] << " [which] [dim] [#points] [range]\n";
std::cout << " which=0 create testset in "<<argv[0]<<".ch\n" ;
std::cout << " which=1 double cartesian\n" ;
std::cout << " which=2 double homogeneous\n" ;
std::cout << " which=4 LEDA integer homogeneous\n" ;
std::cout << " which=8 GNU mpz homogeneous\n" ;
std::cout << " which=16 LEDA real cartesian\n" ;
std::exit(1);
}
if (argc > 1) which = std::atoi(argv[1]);
if (argc > 2) d = std::atoi(argv[2]);
if (argc > 3) n = std::atoi(argv[3]);
if (argc > 4) range = std::atoi(argv[4]);
p_table_file = new std::ofstream(
(std::string(argv[0])+".rts").c_str(), std::ios::app);
int** V;
if ( which == 0 ) {
create(V,n,d);
random_d_tuples_in_range(V,n,d,-range,range);
print_to_file(V,n,d,std::string(argv[0])+".ch");
std::exit(0);
} else {
read_from_file(V,n,d,std::string(argv[0])+".ch");
}
if ( which & 1 ) {
DCConvex_hull_d DCC(d);
time_insertion_and_check(V,n,d,DCC,"double cartesian ");
}
if ( which & 2 ) {
DHConvex_hull_d DHC(d);
time_insertion_and_check(V,n,d,DHC,"double homogeneous ");
}
#ifdef CGAL_USE_LEDA
if ( which & 4 ) {
LHConvex_hull_d LHC(d);
time_insertion_and_check(V,n,d,LHC,"LEDA integer homogeneous");
}
#endif
#ifdef CGAL_USE_GMP
if ( which & 8 ) {
GConvex_hull_d GC(d);
time_insertion_and_check(V,n,d,GC,"GNU mpz homogeneous ");
}
#endif
#ifdef CGAL_USE_LEDA
if ( which & 16 ) {
LCConvex_hull_d LCC(d);
time_insertion_and_check(V,n,d,LCC,"LEDA real cartesian ",false);
}
#endif
#ifdef CGAL_USE_LEDA
#if defined(LEDA_NAMESPACE)
std::cout << "leda::print_statistics() is missing in the free edition" << std::endl;
// leda::print_statistics();
#else
// print_statistics();
#endif
#endif
destroy(V,n);
return 0;
}
/* CTCP: DCC SEND */
static void ctcp_msg_dcc_send(IRC_SERVER_REC *server, const char *data,
const char *nick, const char *addr,
const char *target, CHAT_DCC_REC *chat)
{
GET_DCC_REC *dcc;
SEND_DCC_REC *temp_dcc;
IPADDR ip;
char *address, **params, *fname;
int paramcount, fileparams;
int port, len, quoted = FALSE;
uoff_t size;
int p_id = -1;
int passive = FALSE;
/* SEND <file name> <address> <port> <size> [...] */
/* SEND <file name> <address> 0 <size> <id> (DCC SEND passive protocol) */
params = g_strsplit(data, " ", -1);
paramcount = strarray_length(params);
if (paramcount < 4) {
signal_emit("dcc error ctcp", 5, "SEND", data,
nick, addr, target);
g_strfreev(params);
return;
}
fileparams = get_file_params_count(params, paramcount);
address = g_strdup(params[fileparams]);
dcc_str2ip(address, &ip);
port = atoi(params[fileparams+1]);
size = str_to_uofft(params[fileparams+2]);
/* If this DCC uses passive protocol then store the id for later use. */
if (paramcount == fileparams + 4) {
p_id = atoi(params[fileparams+3]);
passive = TRUE;
}
fname = get_file_name(params, fileparams);
g_strfreev(params);
len = strlen(fname);
if (len > 1 && *fname == '"' && fname[len-1] == '"') {
/* "file name" - MIRC sends filenames with spaces like this */
fname[len-1] = '\0';
g_memmove(fname, fname+1, len);
quoted = TRUE;
}
if (passive && port != 0) {
/* This is NOT a DCC SEND request! This is a reply to our
passive request. We MUST check the IDs and then connect to
the remote host. */
temp_dcc = DCC_SEND(dcc_find_request(DCC_SEND_TYPE, nick, fname));
if (temp_dcc != NULL && p_id == temp_dcc->pasv_id) {
temp_dcc->target = g_strdup(target);
temp_dcc->port = port;
temp_dcc->size = size;
temp_dcc->file_quoted = quoted;
memcpy(&temp_dcc->addr, &ip, sizeof(IPADDR));
if (temp_dcc->addr.family == AF_INET)
net_ip2host(&temp_dcc->addr, temp_dcc->addrstr);
else {
/* with IPv6, show it to us as it was sent */
strocpy(temp_dcc->addrstr, address,
sizeof(temp_dcc->addrstr));
}
/* This new signal is added to let us invoke
dcc_send_connect() which is found in dcc-send.c */
signal_emit("dcc reply send pasv", 1, temp_dcc);
g_free(address);
g_free(fname);
return;
} else if (temp_dcc != NULL && p_id != temp_dcc->pasv_id) {
/* IDs don't match... remove the old DCC SEND and
return */
dcc_destroy(DCC(temp_dcc));
g_free(address);
g_free(fname);
return;
}
}
dcc = DCC_GET(dcc_find_request(DCC_GET_TYPE, nick, fname));
if (dcc != NULL)
dcc_destroy(DCC(dcc)); /* remove the old DCC */
dcc = dcc_get_create(server, chat, nick, fname);
dcc->target = g_strdup(target);
if (passive && port == 0)
dcc->pasv_id = p_id; /* Assign the ID to the DCC */
memcpy(&dcc->addr, &ip, sizeof(ip));
if (dcc->addr.family == AF_INET)
net_ip2host(&dcc->addr, dcc->addrstr);
else {
/* with IPv6, show it to us as it was sent */
strocpy(dcc->addrstr, address, sizeof(dcc->addrstr));
}
dcc->port = port;
dcc->size = size;
dcc->file_quoted = quoted;
signal_emit("dcc request", 2, dcc, addr);
g_free(address);
g_free(fname);
}
/* CTCP: DCC CHAT */
static void ctcp_msg_dcc_chat(IRC_SERVER_REC *server, const char *data,
const char *nick, const char *addr,
const char *target, CHAT_DCC_REC *chat)
{
CHAT_DCC_REC *dcc;
char **params;
int paramcount;
int passive, autoallow = FALSE;
/* CHAT <unused> <address> <port> */
/* CHAT <unused> <address> 0 <id> (DCC CHAT passive protocol) */
params = g_strsplit(data, " ", -1);
paramcount = g_strv_length(params);
if (paramcount < 3) {
g_strfreev(params);
return;
}
passive = paramcount == 4 && g_strcmp0(params[2], "0") == 0;
if (nick == NULL)
nick = "";
dcc = DCC_CHAT(dcc_find_request(DCC_CHAT_TYPE, nick, NULL));
if (dcc != NULL) {
if (dcc_is_listening(dcc)) {
/* we requested dcc chat, they requested
dcc chat from us .. allow it. */
dcc_destroy(DCC(dcc));
autoallow = TRUE;
} else if (!dcc_is_passive(dcc)) {
/* we already have one dcc chat request
from this nick, remove it. */
dcc_destroy(DCC(dcc));
} else if (passive) {
if (dcc->pasv_id != atoi(params[3])) {
/* IDs don't match! */
dcc_destroy(DCC(dcc));
} else {
/* IDs are ok! Update address and port and
connect! */
dcc->target = g_strdup(target);
dcc->port = atoi(params[2]);
dcc_str2ip(params[1], &dcc->addr);
net_ip2host(&dcc->addr, dcc->addrstr);
dcc_chat_connect(dcc);
g_strfreev(params);
return;
}
}
}
dcc = dcc_chat_create(server, chat, nick, params[0]);
if (dcc == NULL) {
g_strfreev(params);
g_warn_if_reached();
return;
}
dcc->target = g_strdup(target);
dcc->port = atoi(params[2]);
if (passive)
dcc->pasv_id = atoi(params[3]);
dcc_str2ip(params[1], &dcc->addr);
net_ip2host(&dcc->addr, dcc->addrstr);
signal_emit("dcc request", 2, dcc, addr);
if (autoallow || DCC_CHAT_AUTOACCEPT(dcc, server, nick, addr)) {
if (passive) {
/* Passive DCC... let's set up a listening socket
and send reply back */
dcc_chat_passive(dcc);
} else {
dcc_chat_connect(dcc);
}
}
g_strfreev(params);
}