NSAPI_PUBLIC Session *session_create(SYS_NETFD csd, struct sockaddr_in *sac)
{
Session *sn = session_alloc(csd, sac);
if (sn)
session_fill(sn);
return sn;
}
/**
* Handler for the EPOLLIN event when the DCB refers to the listening
* socket for the protocol.
*
* @param dcb The descriptor control block
* @return The number of new connections created
*/
static int
telnetd_accept(DCB *dcb)
{
int n_connect = 0;
while (1)
{
int so;
struct sockaddr_in addr;
socklen_t addrlen = sizeof(struct sockaddr);
DCB *client_dcb;
TELNETD* telnetd_pr = NULL;
dcb_state_t old_state = DCB_STATE_UNDEFINED;
bool succp = FALSE;
so = accept(dcb->fd, (struct sockaddr *)&addr, &addrlen);
if (so == -1)
return n_connect;
else
{
atomic_add(&dcb->stats.n_accepts, 1);
client_dcb = dcb_alloc(DCB_ROLE_REQUEST_HANDLER);
if (client_dcb == NULL)
{
return n_connect;
}
client_dcb->fd = so;
client_dcb->remote = strdup(inet_ntoa(addr.sin_addr));
memcpy(&client_dcb->func, &MyObject, sizeof(GWPROTOCOL));
client_dcb->session =
session_alloc(dcb->session->service, client_dcb);
telnetd_pr = (TELNETD *)malloc(sizeof(TELNETD));
client_dcb->protocol = (void *)telnetd_pr;
if (telnetd_pr == NULL)
{
dcb_add_to_zombieslist(client_dcb);
return n_connect;
}
if (poll_add_dcb(client_dcb) == -1)
{
dcb_add_to_zombieslist(dcb);
return n_connect;
}
n_connect++;
telnetd_pr->state = TELNETD_STATE_LOGIN;
telnetd_pr->username = NULL;
dcb_printf(client_dcb, "MaxScale login: ");
}
}
return n_connect;
}
/**
* Handler for the EPOLLIN event when the DCB refers to the listening
* socket for the protocol.
*
* @param dcb The descriptor control block
*/
static int httpd_accept(DCB *dcb)
{
int n_connect = 0;
while (1)
{
int so = -1;
struct sockaddr_in addr;
socklen_t addrlen;
DCB *client = NULL;
HTTPD_session *client_data = NULL;
if ((so = accept(dcb->fd, (struct sockaddr *)&addr, &addrlen)) == -1)
{
return n_connect;
}
else
{
atomic_add(&dcb->stats.n_accepts, 1);
if ((client = dcb_alloc(DCB_ROLE_REQUEST_HANDLER)))
{
client->listen_ssl = dcb->listen_ssl;
client->fd = so;
client->remote = strdup(inet_ntoa(addr.sin_addr));
memcpy(&client->func, &MyObject, sizeof(GWPROTOCOL));
/* create the session data for HTTPD */
client_data = (HTTPD_session *)calloc(1, sizeof(HTTPD_session));
client->data = client_data;
client->session = session_alloc(dcb->session->service, client);
if (NULL == client->session || poll_add_dcb(client) == -1)
{
close(so);
dcb_close(client);
return n_connect;
}
n_connect++;
}
else
{
close(so);
}
}
}
return n_connect;
}
static session_t *
session_alloc_for_connection (transport_connection_t * tc)
{
session_t *s;
u32 thread_index = tc->thread_index;
ASSERT (thread_index == vlib_get_thread_index ()
|| transport_protocol_is_cl (tc->proto));
s = session_alloc (thread_index);
s->session_type = session_type_from_proto_and_ip (tc->proto, tc->is_ip4);
s->session_state = SESSION_STATE_CLOSED;
/* Attach transport to session and vice versa */
s->connection_index = tc->c_index;
tc->s_index = s->session_index;
return s;
}
static struct audio_client *audio_client_alloc(unsigned bufsz)
{
struct audio_client *ac;
int n;
ac = kzalloc(sizeof(*ac), GFP_KERNEL);
if (!ac)
return 0;
n = session_alloc(ac);
if (n < 0)
goto fail_session;
ac->session = n;
if (bufsz > 0) {
ac->buf[0].data = dma_alloc_coherent(NULL, bufsz,
&ac->buf[0].phys, GFP_KERNEL);
if (!ac->buf[0].data)
goto fail;
ac->buf[1].data = dma_alloc_coherent(NULL, bufsz,
&ac->buf[1].phys, GFP_KERNEL);
if (!ac->buf[1].data)
goto fail;
ac->buf[0].size = bufsz;
ac->buf[1].size = bufsz;
}
init_waitqueue_head(&ac->wait);
ac->client = adsp;
return ac;
fail:
session_free(n, ac);
fail_session:
audio_client_free(ac);
return 0;
}
int nfs41_session_create(
IN nfs41_client *client,
IN nfs41_session **session_out)
{
nfs41_session *session;
int status;
status = session_alloc(client, &session);
if (status) {
eprintf("session_alloc() failed with %d\n", status);
goto out;
}
AcquireSRWLockShared(&client->exid_lock);
if (client->rpc->needcb)
session->flags |= CREATE_SESSION4_FLAG_CONN_BACK_CHAN;
session->flags |= CREATE_SESSION4_FLAG_PERSIST;
ReleaseSRWLockShared(&client->exid_lock);
status = nfs41_create_session(client, session, TRUE);
if (status) {
eprintf("nfs41_create_session failed %d\n", status);
status = ERROR_BAD_NET_RESP;
goto out_err;
}
AcquireSRWLockExclusive(&session->client->session_lock);
client->session = session;
session->isValidState = TRUE;
ReleaseSRWLockExclusive(&session->client->session_lock);
*session_out = session;
out:
return status;
out_err:
nfs41_session_free(session);
goto out;
}
int main(int argc, char *argv[], char *envp[])
{
//FIXME:user could choose only a website no all website.which means --host is available.
static const struct option options[] = {
{"debug", 0, NULL, 'd'},
{"verbose", 0, NULL, 'V'},
{"action", 1, NULL, 'A'},
{"logfile", 1, NULL, 'L'},
{"shrink-urls", 0, NULL, 's'},
{"help", 0, NULL, 'h'},
{"bash", 0, NULL, 'b'},
{"background", 0, NULL, 'B'},
{"dry-run", 0, NULL, 'n'},
{"page", 1, NULL, 'g'},
{"version", 0, NULL, 'v'},
{"config", 1, NULL, 'c'},
{"replyto", 1, NULL, 'r'},
{"retweet", 1, NULL, 'w'},
{}
};
struct session *session;
pid_t child;
int retval = 0;
int option;
char *home;
const char *config_file;
time_t t;
int page_nr;
char *tweet;
debug = 0;
session = session_alloc();
if (!session) {
fprintf(stderr, "no more memory...\n");
return -1;
}
/* get the current time so that we can log it later */
time(&t);
session->time = strdup(ctime(&t));
session->time[strlen(session->time) - 1] = 0x00;
/*
* Get the home directory so we can try to find a config file.
* If we have no home dir set up, look in /etc/bti
*/
home = getenv("HOME");
if (home) {
/* We have a home dir, so this might be a user */
session->homedir = strdup(home);
config_file = config_user_default;
} else {
session->homedir = strdup("");
config_file = config_default;
}
/* set up a default config file location (traditionally ~/.bti) */
session->configfile =
zalloc(strlen(session->homedir) + strlen(config_file) + 7);
sprintf(session->configfile, "%s/%s", session->homedir, config_file);
session_readline_init(session);
struct account *account = parse_configfile(session);
if (account == NULL) {
fprintf(stderr, "parse err, goto exit\n");
exit(-1);
}
while (1) {
option = getopt_long_only(argc, argv,
"dp:P:H:a:A:u:c:hg:G:sr:nVvw:",
options, NULL);
if (option == -1)
break;
switch (option) {
case 'd':
debug = 1;
break;
case 'V':
session->verbose = 1;
break;
case 'g':
page_nr = atoi(optarg);
dbg("page = %d\n", page_nr);
session->page = page_nr;
break;
case 'r':
session->replyto = strdup(optarg);
dbg("in_reply_to_status_id = %s\n", session->replyto);
break;
case 'A':
if (strcasecmp(optarg, "update") == 0)
session->action = ACTION_UPDATE;
else if (strcasecmp(optarg, "friends") == 0)
session->action = ACTION_FRIENDS;
else if (strcasecmp(optarg, "user") == 0)
session->action = ACTION_USER;
else if (strcasecmp(optarg, "replies") == 0)
session->action = ACTION_REPLIES;
else if (strcasecmp(optarg, "public") == 0)
session->action = ACTION_PUBLIC;
else if (strcasecmp(optarg, "group") == 0)
session->action = ACTION_GROUP;
else if (strcasecmp(optarg, "retweet") == 0)
session->action = ACTION_RETWEET;
else
session->action = ACTION_UNKNOWN;
dbg("action = %d\n", session->action);
break;
case 'u':
if (session->user)
free(session->user);
session->user = strdup(optarg);
dbg("user = %s\n", session->user);
break;
case 'G':
if (session->group)
free(session->group);
session->group = strdup(optarg);
dbg("group = %s\n", session->group);
break;
case 'L':
if (session->logfile)
free(session->logfile);
session->logfile = strdup(optarg);
dbg("logfile = %s\n", session->logfile);
break;
case 's':
session->shrink_urls = 1;
break;
case 'b':
session->bash = 1;
/* fall-through intended */
case 'B':
session->background = 1;
break;
case 'c':
if (session->configfile)
free(session->configfile);
session->configfile = strdup(optarg);
dbg("configfile = %s\n", session->configfile);
/*
* read the config file now. Yes, this could override
* previously set options from the command line, but
* the user asked for it...
*/
//bti_parse_configfile(session);
break;
case 'h':
display_help();
goto exit;
case 'n':
session->dry_run = 1;
break;
case 'v':
display_version();
goto exit;
default:
display_help();
goto exit;
}
}
/*
* Show the version to make it easier to determine what
* is going on here
*/
if (debug)
display_version();
if (session->action == ACTION_UNKNOWN) {
fprintf(stderr, "Unknown action, valid actions are:\n"
"'update', 'friends', 'public', 'replies', 'group' or 'user'.\n");
goto exit;
}
dbg("config file = %s\n", session->configfile);
dbg("action = %d\n", session->action);
/* fork ourself so that the main shell can get on
* with it's life as we try to connect and handle everything
*/
if (session->background) {
child = fork();
if (child) {
dbg("child is %d\n", child);
exit(0);
}
}
switch (session->action) {
case ACTION_PUBLIC:
PUBLIC(account, session, retval);
break;
case ACTION_UPDATE:
if (session->background || !session->interactive)
tweet = get_string_from_stdin();
else
tweet = session->readline("tweet: ");
if (!tweet || strlen(tweet) == 0) {
dbg("no tweet?\n");
return -1;
}
if (session->shrink_urls)
tweet = shrink_urls(tweet);
session->tweet = zalloc(strlen(tweet) + 10);
if (session->bash)
sprintf(session->tweet, "%c %s",
getuid()? '$' : '#', tweet);
else
sprintf(session->tweet, "%s", tweet);
if (tweet)
free(tweet);
dbg("tweet = %s\n", session->tweet);
UPDATE(account, session, retval);
break;
case ACTION_FRIENDS:
FRIENDS(account, session, retval);
break;
case ACTION_REPLIES:
REPLIES(account, session, retval);
break;
default:
retval = -1;
break;
}
// retval = send_request(session);
if (retval && !session->background)
fprintf(stderr, "operation failed\n");
/* log_session(session, retval); */
DESTORY(account);
exit:
session_readline_cleanup(session);
session_free(session);
return retval;;
}
/*
* Move p to a new or existing process group (and session)
*/
int
enterpgrp(proc_p p, pid_t pgid, int mksess) {
register pgrp_p pgrp = pgfind(pgid);
#ifdef DIAGNOSTIC
if (pgrp != NULL && mksess) /* firewalls */
panic("enterpgrp: setsid into non-empty pgrp");
if (SESS_LEADER(p))
panic("enterpgrp: session leader attempted setpgrp");
#endif
{
extern int getpid();
dprintf("%d enterpgrp(p %p (pid: %d),pgid %d,mksess %d) (pgrp = %p pgid: %d)\n",
getpid(),p,p ? p->p_pid : -1,pgid,mksess, pgrp,pgrp ? pgrp->pg_id : -1);
}
if (pgrp == NULL) {
pid_t savepid = p->p_pid;
proc_p np;
/*
* new process group
*/
#ifdef DIAGNOSTIC
if (p->p_pid != pgid)
panic("enterpgrp: new pgrp and pid != pgid");
#endif
if ((np = __pd_pfind(savepid)) == NULL || np != p)
return (ESRCH);
pgrp = pgrp_alloc();
if (mksess) {
session_p sess;
/*
* new session
*/
sess = session_alloc();
sess->s_leader = p;
sess->s_count = 1;
sess->s_ttyp = (struct tty *)0;
bcopy(p->p_session->s_login, sess->s_login,
sizeof(sess->s_login));
p->p_flag &= ~P_CONTROLT;
pgrp->pg_session = sess;
} else {
pgrp->pg_session = p->p_session;
pgrp->pg_session->s_count++;
}
pgrp->pg_id = pgid;
LIST_INIT(&pgrp->pg_members);
pgrp->pg_jobc = 0;
} else if (pgrp == p->p_pgrp)
return (0);
/*
* Adjust eligibility of affected pgrps to participate in job control.
* Increment eligibility counts before decrementing, otherwise we
* could reach 0 spuriously during the first call.
*/
fixjobc(p, pgrp, 1);
fixjobc(p, p->p_pgrp, 0);
LIST_REMOVE(p, p_pglist);
if (p->p_pgrp->pg_members.lh_first == 0)
pgdelete(p->p_pgrp);
p->p_pgrp = pgrp;
LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
return (0);
}
/**
* Start an individual port/protocol pair
*
* @param service The service
* @param port The port to start
* @return The number of listeners started
*/
static int
serviceStartPort(SERVICE *service, SERV_PROTOCOL *port)
{
int listeners = 0;
char config_bind[40];
GWPROTOCOL *funcs;
port->listener = dcb_alloc(DCB_ROLE_SERVICE_LISTENER);
if (port->listener == NULL)
{
return 0;
}
if (strcmp(port->protocol, "MySQLClient") == 0) {
int loaded;
/* Allocate specific data for MySQL users */
service->users = mysql_users_alloc();
loaded = load_mysql_users(service);
/* At service start last update is set to USERS_REFRESH_TIME seconds earlier.
* This way MaxScale could try reloading users' just after startup
*/
service->rate_limit.last=time(NULL) - USERS_REFRESH_TIME;
service->rate_limit.nloads=1;
LOGIF(LM, (skygw_log_write(
LOGFILE_MESSAGE,
"Loaded %d MySQL Users.",
loaded)));
} else {
/* Generic users table */
service->users = users_alloc();
}
if ((funcs =
(GWPROTOCOL *)load_module(port->protocol, MODULE_PROTOCOL)) == NULL)
{
dcb_free(port->listener);
port->listener = NULL;
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Unable to load protocol module %s. Listener "
"for service %s not started.",
port->protocol,
service->name)));
return 0;
}
memcpy(&(port->listener->func), funcs, sizeof(GWPROTOCOL));
port->listener->session = NULL;
if (port->address)
sprintf(config_bind, "%s:%d", port->address, port->port);
else
sprintf(config_bind, "0.0.0.0:%d", port->port);
if (port->listener->func.listen(port->listener, config_bind)) {
port->listener->session = session_alloc(service, port->listener);
if (port->listener->session != NULL) {
port->listener->session->state = SESSION_STATE_LISTENER;
listeners += 1;
} else {
dcb_close(port->listener);
}
} else {
dcb_close(port->listener);
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Unable to start to listen port %d for %s %s.",
port->port,
port->protocol,
service->name)));
}
return listeners;
}
int main(int argc, char *argv[], char *envp[])
{
static const struct option options[] = {
{ "debug", 0, NULL, 'd' },
{ "verbose", 0, NULL, 'V' },
{ "account", 1, NULL, 'a' },
{ "password", 1, NULL, 'p' },
{ "host", 1, NULL, 'H' },
{ "proxy", 1, NULL, 'P' },
{ "action", 1, NULL, 'A' },
{ "user", 1, NULL, 'u' },
{ "group", 1, NULL, 'G' },
{ "logfile", 1, NULL, 'L' },
{ "shrink-urls", 0, NULL, 's' },
{ "help", 0, NULL, 'h' },
{ "bash", 0, NULL, 'b' },
{ "background", 0, NULL, 'B' },
{ "dry-run", 0, NULL, 'n' },
{ "page", 1, NULL, 'g' },
{ "version", 0, NULL, 'v' },
{ "config", 1, NULL, 'c' },
{ "replyto", 1, NULL, 'r' },
{ "retweet", 1, NULL, 'w' },
{ }
};
struct session *session;
pid_t child;
char *tweet;
static char password[80];
int retval = 0;
int option;
char *http_proxy;
time_t t;
int page_nr;
debug = 0;
session = session_alloc();
if (!session) {
fprintf(stderr, "no more memory...\n");
return -1;
}
/* get the current time so that we can log it later */
time(&t);
session->time = strdup(ctime(&t));
session->time[strlen(session->time)-1] = 0x00;
/* Get the home directory so we can try to find a config file */
session->homedir = strdup(getenv("HOME"));
/* set up a default config file location (traditionally ~/.bti) */
session->configfile = zalloc(strlen(session->homedir) + 7);
sprintf(session->configfile, "%s/.bti", session->homedir);
/* Set environment variables first, before reading command line options
* or config file values. */
http_proxy = getenv("http_proxy");
if (http_proxy) {
if (session->proxy)
free(session->proxy);
session->proxy = strdup(http_proxy);
dbg("http_proxy = %s\n", session->proxy);
}
bti_parse_configfile(session);
while (1) {
option = getopt_long_only(argc, argv,
"dp:P:H:a:A:u:c:hg:G:sr:nVvw:",
options, NULL);
if (option == -1)
break;
switch (option) {
case 'd':
debug = 1;
break;
case 'V':
session->verbose = 1;
break;
case 'a':
if (session->account)
free(session->account);
session->account = strdup(optarg);
dbg("account = %s\n", session->account);
break;
case 'g':
page_nr = atoi(optarg);
dbg("page = %d\n", page_nr);
session->page = page_nr;
break;
case 'r':
session->replyto = strdup(optarg);
dbg("in_reply_to_status_id = %s\n", session->replyto);
break;
case 'w':
session->retweet = strdup(optarg);
dbg("Retweet ID = %s\n", session->retweet);
break;
case 'p':
if (session->password)
free(session->password);
session->password = strdup(optarg);
dbg("password = %s\n", session->password);
break;
case 'P':
if (session->proxy)
free(session->proxy);
session->proxy = strdup(optarg);
dbg("proxy = %s\n", session->proxy);
break;
case 'A':
if (strcasecmp(optarg, "update") == 0)
session->action = ACTION_UPDATE;
else if (strcasecmp(optarg, "friends") == 0)
session->action = ACTION_FRIENDS;
else if (strcasecmp(optarg, "user") == 0)
session->action = ACTION_USER;
else if (strcasecmp(optarg, "replies") == 0)
session->action = ACTION_REPLIES;
else if (strcasecmp(optarg, "public") == 0)
session->action = ACTION_PUBLIC;
else if (strcasecmp(optarg, "group") == 0)
session->action = ACTION_GROUP;
else if (strcasecmp(optarg, "retweet") == 0)
session->action = ACTION_RETWEET;
else
session->action = ACTION_UNKNOWN;
dbg("action = %d\n", session->action);
break;
case 'u':
if (session->user)
free(session->user);
session->user = strdup(optarg);
dbg("user = %s\n", session->user);
break;
case 'G':
if (session->group)
free(session->group);
session->group = strdup(optarg);
dbg("group = %s\n", session->group);
break;
case 'L':
if (session->logfile)
free(session->logfile);
session->logfile = strdup(optarg);
dbg("logfile = %s\n", session->logfile);
break;
case 's':
session->shrink_urls = 1;
break;
case 'H':
if (session->hosturl)
free(session->hosturl);
if (session->hostname)
free(session->hostname);
if (strcasecmp(optarg, "twitter") == 0) {
session->host = HOST_TWITTER;
session->hosturl = strdup(twitter_host);
session->hostname = strdup(twitter_name);
} else if (strcasecmp(optarg, "identica") == 0) {
session->host = HOST_IDENTICA;
session->hosturl = strdup(identica_host);
session->hostname = strdup(identica_name);
} else {
session->host = HOST_CUSTOM;
session->hosturl = strdup(optarg);
session->hostname = strdup(optarg);
}
dbg("host = %d\n", session->host);
break;
case 'b':
session->bash = 1;
/* fall-through intended */
case 'B':
session->background = 1;
break;
case 'c':
if (session->configfile)
free(session->configfile);
session->configfile = strdup(optarg);
dbg("configfile = %s\n", session->configfile);
/*
* read the config file now. Yes, this could override
* previously set options from the command line, but
* the user asked for it...
*/
bti_parse_configfile(session);
break;
case 'h':
display_help();
goto exit;
case 'n':
session->dry_run = 1;
break;
case 'v':
display_version();
goto exit;
default:
display_help();
goto exit;
}
}
session_readline_init(session);
/*
* Show the version to make it easier to determine what
* is going on here
*/
if (debug)
display_version();
if (session->host == HOST_TWITTER) {
if (!session->consumer_key || !session->consumer_secret) {
if (session->action == ACTION_USER ||
session->action == ACTION_PUBLIC) {
/*
* Some actions may still work without
* authentication
*/
session->guest = 1;
} else {
fprintf(stderr,
"Twitter no longer supports HTTP basic authentication.\n"
"Both consumer key, and consumer secret are required"
" for bti in order to behave as an OAuth consumer.\n");
goto exit;
}
}
if (session->action == ACTION_GROUP) {
fprintf(stderr, "Groups only work in Identi.ca.\n");
goto exit;
}
} else {
if (!session->consumer_key || !session->consumer_secret)
session->no_oauth = 1;
}
if (session->no_oauth) {
if (!session->account) {
fprintf(stdout, "Enter account for %s: ",
session->hostname);
session->account = session->readline(NULL);
}
if (!session->password) {
read_password(password, sizeof(password),
session->hostname);
session->password = strdup(password);
}
} else if (!session->guest) {
if (!session->access_token_key ||
!session->access_token_secret) {
request_access_token(session);
goto exit;
}
}
if (session->action == ACTION_UNKNOWN) {
fprintf(stderr, "Unknown action, valid actions are:\n"
"'update', 'friends', 'public', 'replies', 'group' or 'user'.\n");
goto exit;
}
if (session->action == ACTION_GROUP && !session->group) {
fprintf(stdout, "Enter group name: ");
session->group = session->readline(NULL);
}
if (session->action == ACTION_RETWEET) {
if (!session->retweet) {
char *rtid;
fprintf(stdout, "Status ID to retweet: ");
rtid = get_string_from_stdin();
session->retweet = zalloc(strlen(rtid) + 10);
sprintf(session->retweet, "%s", rtid);
free(rtid);
}
if (!session->retweet || strlen(session->retweet) == 0) {
dbg("no retweet?\n");
return -1;
}
dbg("retweet ID = %s\n", session->retweet);
}
if (session->action == ACTION_UPDATE) {
if (session->background || !session->interactive)
tweet = get_string_from_stdin();
else
tweet = session->readline("tweet: ");
if (!tweet || strlen(tweet) == 0) {
dbg("no tweet?\n");
return -1;
}
if (session->shrink_urls)
tweet = shrink_urls(tweet);
session->tweet = zalloc(strlen(tweet) + 10);
if (session->bash)
sprintf(session->tweet, "%c %s",
getuid() ? '$' : '#', tweet);
else
sprintf(session->tweet, "%s", tweet);
free(tweet);
dbg("tweet = %s\n", session->tweet);
}
if (session->page == 0)
session->page = 1;
dbg("config file = %s\n", session->configfile);
dbg("host = %d\n", session->host);
dbg("action = %d\n", session->action);
/* fork ourself so that the main shell can get on
* with it's life as we try to connect and handle everything
*/
if (session->background) {
child = fork();
if (child) {
dbg("child is %d\n", child);
exit(0);
}
}
retval = send_request(session);
if (retval && !session->background)
fprintf(stderr, "operation failed\n");
log_session(session, retval);
exit:
session_readline_cleanup(session);
session_free(session);
return retval;;
}
static int
do_client()
{
int rc = -1;
char *buf;
grn_thread thread;
struct timeval tvb, tve;
grn_com_header sheader;
grn_ctx ctx_, *ctx = &ctx_;
grn_ctx_init(ctx, 0);
GRN_COM_QUEUE_INIT(&fsessions);
sessions = grn_hash_create(ctx, NULL, sizeof(grn_sock), sizeof(session), 0);
sheader.proto = GRN_COM_PROTO_GQTP;
sheader.qtype = 0;
sheader.keylen = 0;
sheader.level = 0;
sheader.flags = 0;
sheader.status = 0;
sheader.opaque = 0;
sheader.cas = 0;
if ((buf = GRN_MALLOC(BUFSIZE))) {
if (!grn_com_event_init(ctx, &ev, 1000, sizeof(grn_com))) {
ev.msg_handler = msg_handler;
if (!THREAD_CREATE(thread, receiver, NULL)) {
int cnt = 0;
gettimeofday(&tvb, NULL);
lprint(ctx, "begin: max_concurrency=%d max_tp=%d", max_con, max_tp);
while (fgets(buf, BUFSIZE, stdin)) {
uint32_t size = strlen(buf) - 1;
session *s = session_alloc(ctx, dests + (cnt++ % dest_cnt));
if (s) {
gettimeofday(&s->tv, NULL);
s->n_query++;
s->query_id = ++nsent;
s->n_sessions = (nsent - nrecv);
switch (proto) {
case 'H' :
case 'h' :
if (grn_com_send_text(ctx, s->com, buf, size, 0)) {
fprintf(stderr, "grn_com_send_text failed\n");
}
s->stat = 2;
/*
lprint(ctx, "sent %04d %04d %d",
s->n_query, s->query_id, s->com->fd);
*/
break;
default :
if (grn_com_send(ctx, s->com, &sheader, buf, size, 0)) {
fprintf(stderr, "grn_com_send failed\n");
}
break;
}
} else {
fprintf(stderr, "grn_com_copen failed\n");
}
for (;;) {
gettimeofday(&tve, NULL);
if ((nrecv < max_tp * (tve.tv_sec - tvb.tv_sec)) &&
(nsent - nrecv) < max_con) {
break;
}
/* lprint(ctx, "s:%d r:%d", nsent, nrecv); */
usleep(1000);
}
if (!(nsent % 1000)) {
lprint(ctx, " : %d", nsent);
}
}
done = 1;
pthread_join(thread, NULL);
gettimeofday(&tve, NULL);
{
double qps;
uint64_t etime = (tve.tv_sec - tvb.tv_sec);
etime *= 1000000;
etime += (tve.tv_usec - tvb.tv_usec);
qps = (double)nsent * 1000000 / etime;
lprint(ctx, "end : n=%d min=%d max=%d avg=%d qps=%f etime=%d.%06d", nsent, etime_min, etime_max, (int)(etime_amount / nsent), qps, etime / 1000000, etime % 1000000);
}
{
session *s;
GRN_HASH_EACH(ctx, sessions, id, NULL, NULL, &s, {
session_close(ctx, s);
});
}
rc = 0;
} else {
/**
* Associate a new session with this instance of the filter.
*
* Create the file to log to and open it.
*
* @param instance The filter instance data
* @param session The session itself
* @return Session specific data for this session
*/
static void *
newSession(FILTER *instance, SESSION *session)
{
TEE_INSTANCE *my_instance = (TEE_INSTANCE *) instance;
TEE_SESSION *my_session;
char *remote, *userName;
if (strcmp(my_instance->service->name, session->service->name) == 0)
{
MXS_ERROR("%s: Recursive use of tee filter in service.",
session->service->name);
my_session = NULL;
goto retblock;
}
HASHTABLE* ht = hashtable_alloc(100, simple_str_hash, strcmp);
bool is_loop = detect_loops(my_instance, ht, session->service);
hashtable_free(ht);
if (is_loop)
{
MXS_ERROR("%s: Recursive use of tee filter in service.",
session->service->name);
my_session = NULL;
goto retblock;
}
if ((my_session = calloc(1, sizeof(TEE_SESSION))) != NULL)
{
my_session->active = 1;
my_session->residual = 0;
my_session->tee_replybuf = NULL;
my_session->client_dcb = session->client;
my_session->instance = my_instance;
my_session->client_multistatement = false;
my_session->queue = NULL;
spinlock_init(&my_session->tee_lock);
if (my_instance->source &&
(remote = session_get_remote(session)) != NULL)
{
if (strcmp(remote, my_instance->source))
{
my_session->active = 0;
MXS_WARNING("Tee filter is not active.");
}
}
userName = session_getUser(session);
if (my_instance->userName &&
userName &&
strcmp(userName, my_instance->userName))
{
my_session->active = 0;
MXS_WARNING("Tee filter is not active.");
}
if (my_session->active)
{
DCB* dcb;
SESSION* ses;
FILTER_DEF* dummy;
UPSTREAM* dummy_upstream;
if ((dcb = dcb_clone(session->client)) == NULL)
{
freeSession(instance, (void *) my_session);
my_session = NULL;
MXS_ERROR("Creating client DCB for Tee "
"filter failed. Terminating session.");
goto retblock;
}
if ((dummy = filter_alloc("tee_dummy", "tee_dummy")) == NULL)
{
dcb_close(dcb);
freeSession(instance, (void *) my_session);
my_session = NULL;
MXS_ERROR("tee: Allocating memory for "
"dummy filter definition failed."
" Terminating session.");
goto retblock;
}
if ((ses = session_alloc(my_instance->service, dcb)) == NULL)
{
filter_free(dummy);
dcb_close(dcb);
freeSession(instance, (void *) my_session);
my_session = NULL;
MXS_ERROR("Creating client session for Tee "
"filter failed. Terminating session.");
goto retblock;
}
ss_dassert(ses->ses_is_child);
dummy->obj = GetModuleObject();
dummy->filter = NULL;
my_session->branch_session = ses;
my_session->branch_dcb = dcb;
my_session->dummy_filterdef = dummy;
if ((dummy_upstream = filterUpstream(
dummy, my_session, &ses->tail)) == NULL)
{
filter_free(dummy);
closeSession(instance, (void*) my_session);
dcb_close(dcb);
free(my_session);
MXS_ERROR("tee: Allocating memory for"
"dummy upstream failed."
" Terminating session.");
return NULL;
}
ses->tail = *dummy_upstream;
MySQLProtocol* protocol = (MySQLProtocol*) session->client->protocol;
my_session->use_ok = protocol->client_capabilities & (1 << 6);
free(dummy_upstream);
}
}
retblock:
return my_session;
}
/**
* Start an individual port/protocol pair
*
* @param service The service
* @param port The port to start
* @return The number of listeners started
*/
static int
serviceStartPort(SERVICE *service, SERV_PROTOCOL *port)
{
int listeners = 0;
char config_bind[40];
GWPROTOCOL *funcs;
port->listener = dcb_alloc(DCB_ROLE_SERVICE_LISTENER);
if (port->listener == NULL)
{
return 0;
}
if (strcmp(port->protocol, "MySQLClient") == 0) {
int loaded = load_mysql_users(service);
LOGIF(LM, (skygw_log_write(
LOGFILE_MESSAGE,
"Loaded %d MySQL Users.",
loaded)));
}
if ((funcs =
(GWPROTOCOL *)load_module(port->protocol, MODULE_PROTOCOL)) == NULL)
{
dcb_free(port->listener);
port->listener = NULL;
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Unable to load protocol module %s. Listener "
"for service %s not started.",
port->protocol,
service->name)));
return 0;
}
memcpy(&(port->listener->func), funcs, sizeof(GWPROTOCOL));
port->listener->session = NULL;
if (port->address)
sprintf(config_bind, "%s:%d", port->address, port->port);
else
sprintf(config_bind, "0.0.0.0:%d", port->port);
if (port->listener->func.listen(port->listener, config_bind)) {
port->listener->session = session_alloc(service, port->listener);
if (port->listener->session != NULL) {
port->listener->session->state = SESSION_STATE_LISTENER;
listeners += 1;
} else {
dcb_close(port->listener);
}
} else {
dcb_close(port->listener);
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Unable to start to listen port %d for %s %s.",
port->port,
port->protocol,
service->name)));
}
return listeners;
}
/**
* Start an individual port/protocol pair
*
* @param service The service
* @param port The port to start
* @return The number of listeners started
*/
static int
serviceStartPort(SERVICE *service, SERV_PROTOCOL *port)
{
int listeners = 0;
char config_bind[40];
GWPROTOCOL *funcs;
port->listener = dcb_alloc(DCB_ROLE_SERVICE_LISTENER);
if (port->listener == NULL)
{
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Failed to create listener for service %s.",
service->name)));
goto retblock;
}
if (strcmp(port->protocol, "MySQLClient") == 0) {
int loaded;
if (service->users == NULL) {
/*
* Allocate specific data for MySQL users
* including hosts and db names
*/
service->users = mysql_users_alloc();
if ((loaded = load_mysql_users(service)) < 0)
{
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Unable to load users from %s:%d for "
"service %s.",
(port->address == NULL ? "0.0.0.0" : port->address),
port->port,
service->name)));
{
/* Try loading authentication data from file cache */
char *ptr, path[4097];
strcpy(path, "/usr/local/mariadb-maxscale");
if ((ptr = getenv("MAXSCALE_HOME")) != NULL)
{
strncpy(path, ptr, 4096);
}
strncat(path, "/", 4096);
strncat(path, service->name, 4096);
strncat(path, "/.cache/dbusers", 4096);
loaded = dbusers_load(service->users, path);
if (loaded != -1)
{
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Using cached credential information.")));
}
}
if (loaded == -1)
{
hashtable_free(service->users->data);
free(service->users);
dcb_free(port->listener);
port->listener = NULL;
goto retblock;
}
}
else
{
/* Save authentication data to file cache */
char *ptr, path[4097];
int mkdir_rval = 0;
strcpy(path, "/usr/local/mariadb-maxscale");
if ((ptr = getenv("MAXSCALE_HOME")) != NULL)
{
strncpy(path, ptr, 4096);
}
strncat(path, "/", 4096);
strncat(path, service->name, 4096);
if (access(path, R_OK) == -1)
{
mkdir_rval = mkdir(path, 0777);
}
if(mkdir_rval)
{
skygw_log_write(LOGFILE_ERROR,"Error : Failed to create directory '%s': [%d] %s",
path,
errno,
strerror(errno));
mkdir_rval = 0;
}
strncat(path, "/.cache", 4096);
if (access(path, R_OK) == -1)
{
mkdir_rval = mkdir(path, 0777);
}
if(mkdir_rval)
{
skygw_log_write(LOGFILE_ERROR,"Error : Failed to create directory '%s': [%d] %s",
path,
errno,
strerror(errno));
mkdir_rval = 0;
}
strncat(path, "/dbusers", 4096);
dbusers_save(service->users, path);
}
if (loaded == 0)
{
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Service %s: failed to load any user "
"information. Authentication will "
"probably fail as a result.",
service->name)));
}
/* At service start last update is set to USERS_REFRESH_TIME seconds earlier.
* This way MaxScale could try reloading users' just after startup
*/
service->rate_limit.last=time(NULL) - USERS_REFRESH_TIME;
service->rate_limit.nloads=1;
LOGIF(LM, (skygw_log_write(
LOGFILE_MESSAGE,
"Loaded %d MySQL Users for service [%s].",
loaded, service->name)));
}
}
else
{
if (service->users == NULL) {
/* Generic users table */
service->users = users_alloc();
}
}
if ((funcs=(GWPROTOCOL *)load_module(port->protocol, MODULE_PROTOCOL))
== NULL)
{
if (service->users->data)
{
hashtable_free(service->users->data);
}
free(service->users);
dcb_free(port->listener);
port->listener = NULL;
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Unable to load protocol module %s. Listener "
"for service %s not started.",
port->protocol,
service->name)));
goto retblock;
}
memcpy(&(port->listener->func), funcs, sizeof(GWPROTOCOL));
port->listener->session = NULL;
if (port->address)
sprintf(config_bind, "%s:%d", port->address, port->port);
else
sprintf(config_bind, "0.0.0.0:%d", port->port);
if (port->listener->func.listen(port->listener, config_bind))
{
port->listener->session = session_alloc(service, port->listener);
if (port->listener->session != NULL)
{
port->listener->session->state = SESSION_STATE_LISTENER;
listeners += 1;
}
else
{
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Failed to create session to service %s.",
service->name)));
if (service->users->data)
{
hashtable_free(service->users->data);
}
free(service->users);
dcb_close(port->listener);
port->listener = NULL;
goto retblock;
}
}
else
{
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Unable to start to listen port %d for %s %s.",
port->port,
port->protocol,
service->name)));
if (service->users->data)
{
hashtable_free(service->users->data);
}
free(service->users);
dcb_close(port->listener);
port->listener = NULL;
}
retblock:
return listeners;
}
int
ct_session_connect_notify (session_t * ss)
{
ct_connection_t *sct, *cct;
app_worker_t *client_wrk;
segment_manager_t *sm;
fifo_segment_t *seg;
u64 segment_handle;
int is_fail = 0;
session_t *cs;
u32 ss_index;
ss_index = ss->session_index;
sct = (ct_connection_t *) session_get_transport (ss);
client_wrk = app_worker_get (sct->client_wrk);
sm = segment_manager_get (ss->rx_fifo->segment_manager);
seg = segment_manager_get_segment_w_lock (sm, ss->rx_fifo->segment_index);
segment_handle = segment_manager_segment_handle (sm, seg);
if (app_worker_add_segment_notify (client_wrk, segment_handle))
{
clib_warning ("failed to notify client %u of new segment",
sct->client_wrk);
segment_manager_segment_reader_unlock (sm);
session_close (ss);
is_fail = 1;
}
else
{
segment_manager_segment_reader_unlock (sm);
}
/* Alloc client session */
cct = ct_connection_get (sct->peer_index);
cs = session_alloc (0);
ss = session_get (ss_index, 0);
cs->session_type = ss->session_type;
cs->connection_index = sct->c_c_index;
cs->listener_index = SESSION_INVALID_INDEX;
cs->session_state = SESSION_STATE_CONNECTING;
cs->app_wrk_index = client_wrk->wrk_index;
cs->connection_index = cct->c_c_index;
cct->c_s_index = cs->session_index;
cct->client_rx_fifo = ss->tx_fifo;
cct->client_tx_fifo = ss->rx_fifo;
cct->client_rx_fifo->refcnt++;
cct->client_tx_fifo->refcnt++;
/* This will allocate fifos for the session. They won't be used for
* exchanging data but they will be used to close the connection if
* the segment manager/worker is freed */
if (app_worker_init_connected (client_wrk, cs))
{
session_close (ss);
return -1;
}
if (app_worker_connect_notify (client_wrk, is_fail ? 0 : cs,
sct->client_opaque))
{
session_close (ss);
return -1;
}
cs = session_get (cct->c_s_index, 0);
cs->session_state = SESSION_STATE_READY;
return 0;
}
static int
ct_connect (app_worker_t * client_wrk, session_t * ll,
session_endpoint_cfg_t * sep)
{
u32 cct_index, ll_index, ll_ct_index;
ct_connection_t *sct, *cct, *ll_ct;
app_worker_t *server_wrk;
session_t *ss;
ll_index = ll->session_index;
ll_ct_index = ll->connection_index;
cct = ct_connection_alloc ();
cct_index = cct->c_c_index;
sct = ct_connection_alloc ();
ll_ct = ct_connection_get (ll_ct_index);
/*
* Alloc and init client transport
*/
cct = ct_connection_get (cct_index);
cct->c_thread_index = 0;
cct->c_rmt_port = sep->port;
cct->c_lcl_port = 0;
cct->c_is_ip4 = sep->is_ip4;
clib_memcpy (&cct->c_rmt_ip, &sep->ip, sizeof (sep->ip));
cct->actual_tp = ll_ct->actual_tp;
cct->is_client = 1;
/*
* Init server transport
*/
sct->c_thread_index = 0;
sct->c_rmt_port = 0;
sct->c_lcl_port = ll_ct->c_lcl_port;
sct->c_is_ip4 = sep->is_ip4;
clib_memcpy (&sct->c_lcl_ip, &ll_ct->c_lcl_ip, sizeof (ll_ct->c_lcl_ip));
sct->client_wrk = client_wrk->wrk_index;
sct->c_proto = TRANSPORT_PROTO_NONE;
sct->client_opaque = sep->opaque;
sct->actual_tp = ll_ct->actual_tp;
sct->peer_index = cct->c_c_index;
cct->peer_index = sct->c_c_index;
/*
* Accept server session. Client session is created only after
* server confirms accept.
*/
ss = session_alloc (0);
ll = listen_session_get (ll_index);
ss->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE,
sct->c_is_ip4);
ss->connection_index = sct->c_c_index;
ss->listener_index = ll->session_index;
ss->session_state = SESSION_STATE_CREATED;
server_wrk = application_listener_select_worker (ll);
ss->app_wrk_index = server_wrk->wrk_index;
sct->c_s_index = ss->session_index;
sct->server_wrk = ss->app_wrk_index;
if (ct_init_local_session (client_wrk, server_wrk, sct, ss, ll))
{
clib_warning ("failed");
ct_connection_free (sct);
session_free (ss);
return -1;
}
ss->session_state = SESSION_STATE_ACCEPTING;
if (app_worker_accept_notify (server_wrk, ss))
{
clib_warning ("failed");
ct_connection_free (sct);
session_free_w_fifos (ss);
return -1;
}
cct->segment_handle = sct->segment_handle;
ct_enable_disable_main_pre_input_node (1 /* is_add */ );
return 0;
}
