JNIEXPORT void JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_setCertExpiryWarning(
JNIEnv *jenv, jobject jobj, jint arg)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return;
openconnect_set_cert_expiry_warning(ctx->vpninfo, arg);
}
JNIEXPORT void JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_setSystemTrust(
JNIEnv *jenv, jobject jobj, jboolean arg)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return;
openconnect_set_system_trust(ctx->vpninfo, arg);
}
JNIEXPORT void JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_clearCookie(
JNIEnv *jenv, jobject jobj)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return;
openconnect_clear_cookie(ctx->vpninfo);
}
JNIEXPORT void JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_resetSSL(
JNIEnv *jenv, jobject jobj)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return;
openconnect_reset_ssl(ctx->vpninfo);
}
JNIEXPORT jint JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_getPort(
JNIEnv *jenv, jobject jobj)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return -EINVAL;
return openconnect_get_port(ctx->vpninfo);
}
JNIEXPORT jint JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_passphraseFromFSID(
JNIEnv *jenv, jobject jobj)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return -EINVAL;
return openconnect_passphrase_from_fsid(ctx->vpninfo);
}
JNIEXPORT jint JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_mainloop(
JNIEnv *jenv, jobject jobj, jint arg0, jint arg1)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return -EINVAL;
return openconnect_mainloop(ctx->vpninfo, arg0, arg1);
}
JNIEXPORT jint JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_obtainCookie(
JNIEnv *jenv, jobject jobj)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return 0;
return openconnect_obtain_cookie(ctx->vpninfo);
}
static int handle_update_req (flux_t *h, int64_t j, const char *k,
const char *jcbstr, const char *n)
{
jstatctx_t *ctx = NULL;
ctx = getctx (h);
ctx->op = n? open_test_outfile (n) : stdout;
return (jsc_update_jcb (ctx->h, j, k, jcbstr));
}
JNIEXPORT void JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_setDPD(
JNIEnv *jenv, jobject jobj, jint arg)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return;
openconnect_set_dpd(ctx->vpninfo, arg);
}
JNIEXPORT jint JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_makeCSTPConnection(
JNIEnv *jenv, jobject jobj)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return -EINVAL;
return openconnect_make_cstp_connection(ctx->vpninfo);
}
JNIEXPORT jint JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_setupTunFD(
JNIEnv *jenv, jobject jobj, jint arg)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return -EINVAL;
return openconnect_setup_tun_fd(ctx->vpninfo, arg);
}
static void write_cmd_pipe(JNIEnv *jenv, jobject jobj, char cmd)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return;
if (write(ctx->cmd_fd, &cmd, 1) < 0) {
/* probably dead already */
}
}
int mod_main (flux_t h, int argc, char **argv)
{
ctx_t *ctx = getctx (h);
char *sockpath = NULL, *dfltpath = NULL;
int rc = -1;
/* Parse args.
*/
if (argc > 0)
sockpath = argv[0];
if (!sockpath)
sockpath = dfltpath = xasprintf ("%s/flux-api", flux_get_tmpdir ());
/* Create listen socket and watcher to handle new connections
*/
if ((ctx->listen_fd = listener_init (ctx, sockpath)) < 0)
goto done;
if (!(ctx->listen_w = flux_fd_watcher_create (ctx->listen_fd,
FLUX_POLLIN | FLUX_POLLERR,
listener_cb, ctx))) {
flux_log (h, LOG_ERR, "flux_fd_watcher_create: %s", strerror (errno));
goto done;
}
flux_fd_watcher_start (h, ctx->listen_w);
/* Create/start event/response message watchers
*/
if (flux_msg_watcher_addvec (h, htab, ctx) < 0) {
flux_log (h, LOG_ERR, "flux_msg_watcher_addvec: %s", strerror (errno));
goto done;
}
/* Start reactor
*/
if (flux_reactor_start (h) < 0) {
flux_log (h, LOG_ERR, "flux_reactor_start: %s", strerror (errno));
goto done;
}
rc = 0;
done:
if (dfltpath)
free (dfltpath);
flux_msg_watcher_delvec (h, htab);
flux_fd_watcher_destroy (ctx->listen_w);
if (ctx->listen_fd >= 0) {
if (close (ctx->listen_fd) < 0)
flux_log (h, LOG_ERR, "close listen_fd: %s", strerror (errno));
}
if (ctx->clients) {
client_t *c;
while ((c = zlist_pop (ctx->clients)))
client_destroy (c);
}
return rc;
}
/* Return number of queued clog requests
*/
void count_request_cb (flux_t h, flux_msg_handler_t *w,
const flux_msg_t *msg, void *arg)
{
ctx_t *ctx = getctx (h);
JSON o = Jnew ();
Jadd_int (o, "count", zlist_size (ctx->clog_requests));
if (flux_respond (h, msg, 0, Jtostr (o)) < 0)
flux_log_error (h, "%s: flux_json_respond", __FUNCTION__);
Jput (o);
}
/*
** err = ctx:set_cipher_list(cipher)
*/
static int l_set_cipher_list(lua_State *L)
{
SSL_CTX *ctx = getctx(L);
const char *list = luaL_checkstring(L, 2);
int err = 0;
if (SSL_CTX_set_cipher_list(ctx, list) != 1)
err = ERR_get_error();
lua_pushinteger(L, err);
return 1;
}
/* Return number of queued clog requests
*/
static int count_request_cb (flux_t h, int typemask, zmsg_t **zmsg, void *arg)
{
ctx_t *ctx = getctx (h);
JSON o = Jnew ();
Jadd_int (o, "count", zlist_size (ctx->clog_requests));
if (flux_json_respond (h, o, zmsg) < 0)
flux_log (h, LOG_ERR, "%s: flux_json_respond: %s", __FUNCTION__,
strerror (errno));
Jput (o);
return 0;
}
int flux_attr_fake (flux_t *h, const char *name, const char *val, int flags)
{
attr_ctx_t *ctx = getctx (h);
attr_t *attr = attr_create (val, flags);
if (!ctx || !attr)
return -1;
zhash_update (ctx->hash, name, attr);
zhash_freefn (ctx->hash, name, attr_destroy);
return 0;
}
JNIEXPORT void JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_free(
JNIEnv *jenv, jobject jobj)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return;
openconnect_vpninfo_free(ctx->vpninfo);
(*jenv)->DeleteGlobalRef(jenv, ctx->async_lock);
(*jenv)->DeleteGlobalRef(jenv, ctx->jobj);
free(ctx);
}
/*
** err = ctx:use_certfile(filepath)
*/
static int l_use_certfile(lua_State *L)
{
SSL_CTX *ctx = getctx(L);
const char *filename = luaL_checkstring(L, 2);
int err = 0;
if (SSL_CTX_use_certificate_chain_file(ctx, filename) != 1)
err = ERR_get_error();
lua_pushinteger(L, err);
return 1;
}
JNIEXPORT void JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_setLogLevel(
JNIEnv *jenv, jobject jobj, jint arg)
{
struct libctx *ctx = getctx(jenv, jobj);
if (!ctx)
return;
(*ctx->jenv)->MonitorEnter(ctx->jenv, ctx->async_lock);
ctx->loglevel = arg;
(*ctx->jenv)->MonitorExit(ctx->jenv, ctx->async_lock);
}
static int new_job_cb (const char *key, int64_t val, void *arg, int errnum)
{
int64_t nj = 0;
int64_t js = 0;
JSON ss = NULL;
JSON jcb = NULL;
char k[20] = {'\0'};
char path[20] = {'\0'};
flux_t h = (flux_t) arg;
jscctx_t *ctx = getctx (h);
if (ctx->first_time == 1) {
/* watch is invoked immediately and we shouldn't
* rely on that event at all.
*/
ctx->first_time = 0;
return 0;
}
if (chk_errnum (h, errnum) < 0) return 0;
flux_log (h, LOG_DEBUG, "new_job_cb invoked: key(%s), val(%ld)", key, val);
js = J_NULL;
nj = val-1;
snprintf (k, 20, "%ld", nj);
snprintf (path, 20, "lwj.%ld", nj);
if (zhash_insert (ctx->active_jobs, k, (void *)(intptr_t)js) < 0) {
flux_log (h, LOG_ERR, "new_job_cb: inserting a job to hash failed");
goto done;
}
flux_log (h, LOG_DEBUG, "jobstate_hdlr registered");
jcb = Jnew ();
ss = Jnew ();
Jadd_int64 (jcb, JSC_JOBID, nj);
Jadd_int64 (ss, JSC_STATE_PAIR_OSTATE , (int64_t) js);
Jadd_int64 (ss, JSC_STATE_PAIR_NSTATE, (int64_t) js);
json_object_object_add (jcb, JSC_STATE_PAIR, ss);
if (invoke_cbs (h, nj, jcb, errnum) < 0) {
flux_log (h, LOG_ERR, "new_job_cb: failed to invoke callbacks");
}
if (reg_jobstate_hdlr (h, path, job_state_cb) == -1) {
flux_log (h, LOG_ERR, "new_job_cb: reg_jobstate_hdlr: %s",
strerror (errno));
}
done:
/* always return 0 so that reactor won't return */
return 0;
}
static int invoke_cbs (flux_t *h, int64_t j, json_object *jcb, int errnum)
{
int rc = 0;
cb_pair_t *c = NULL;
jscctx_t *ctx = getctx (h);
for (c = zlist_first (ctx->callbacks); c; c = zlist_next (ctx->callbacks)) {
if (c->cb (jcb, c->arg, errnum) < 0) {
flux_log (h, LOG_ERR, "callback returns an error");
rc = -1;
}
}
return rc;
}
/*
** err = ctx:load_verify_locations(cafile=nil, capath=nil)
** succeed if err == 0
*/
static int l_load_verify_locations(lua_State *L)
{
SSL_CTX *ctx = getctx(L);
const char *cafile = luaL_optstring(L, 2, NULL);
const char *capath = luaL_optstring(L, 2, NULL);
int err = 0;
if (SSL_CTX_load_verify_locations(ctx, cafile, capath) != 1)
err = ERR_get_error();
lua_pushinteger(L, err);
return 1;
}
int mod_main (flux_t *h, int argc, char **argv)
{
zhash_t *args = zhash_fromargv (argc, argv);
ctx_t *ctx;
char *eoc_str;
bool exit_on_complete;
uint32_t rank;
if (flux_get_rank (h, &rank) < 0)
return -1;
if (rank != 0) {
flux_log (h, LOG_ERR, "sim module must only run on rank 0");
return -1;
}
flux_log (h, LOG_INFO, "sim comms module starting");
if (!(eoc_str = zhash_lookup (args, "exit-on-complete"))) {
flux_log (h,
LOG_ERR,
"exit-on-complete argument is not set, defaulting to false");
exit_on_complete = false;
} else {
exit_on_complete =
(!strcmp (eoc_str, "true") || !strcmp (eoc_str, "True"));
}
ctx = getctx (h, exit_on_complete);
if (flux_event_subscribe (h, "rdl.update") < 0) {
flux_log (h, LOG_ERR, "subscribing to event: %s", strerror (errno));
return -1;
}
if (flux_msg_handler_addvec (h, htab, ctx) < 0) {
flux_log (h, LOG_ERR, "flux_msg_handler_add: %s", strerror (errno));
return -1;
}
if (send_start_event (h) < 0) {
flux_log (h, LOG_ERR, "sim failed to send start event");
return -1;
}
flux_log (h, LOG_DEBUG, "sim sent start event");
if (flux_reactor_run (flux_get_reactor (h), 0) < 0) {
flux_log (h, LOG_ERR, "flux_reactor_run: %s", strerror (errno));
return -1;
}
return 0;
}
int mod_main (flux_t h, int argc, char **argv)
{
ctx_t *ctx = getctx (h);
if (flux_msghandler_addvec (h, htab, htablen, ctx) < 0) {
flux_log (h, LOG_ERR, "flux_msghandler_addvec: %s", strerror (errno));
return -1;
}
if (flux_reactor_start (h) < 0) {
flux_log (h, LOG_ERR, "flux_reactor_start: %s", strerror (errno));
return -1;
}
return 0;
}
int main (int argc, char *argv[])
{
flux_t h;
int ch = 0;
int64_t jobid = -1;
char *sfn = NULL;
char *cfn = NULL;
wjctx_t *ctx = NULL;
log_init ("flux-waitjob");
while ((ch = getopt_long (argc, argv, OPTIONS, longopts, NULL)) != -1) {
switch (ch) {
case 'h': /* --help */
usage ();
break;
case 's': /* --sync-start */
sfn = xstrdup (optarg);
break;
case 'c': /* --sync-complete */
cfn = xstrdup (optarg);
break;
default:
usage ();
break;
}
}
if (optind == argc)
usage ();
jobid = strtol (argv[optind], NULL, 10);
if (jobid <= 0)
log_err_exit ("jobid must be a positive number");
else if (!(h = flux_open (NULL, 0)))
log_err_exit ("flux_open");
ctx = getctx (h);
if (sfn)
ctx->start = sfn;
if (cfn)
ctx->complete = cfn;
ctx->jobid = jobid;
flux_log_set_appname (h, "waitjob");
wait_job_complete (h);
flux_close (h);
log_fini ();
return 0;
}
/* special handling: two string arguments */
JNIEXPORT void JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_setClientCert(
JNIEnv *jenv, jobject jobj, jstring jcert, jstring jsslkey)
{
struct libctx *ctx = getctx(jenv, jobj);
const char *cert = NULL, *sslkey = NULL;
if (ctx && !get_cstring(ctx->jenv, jcert, &cert) &&
!get_cstring(ctx->jenv, jsslkey, &sslkey))
openconnect_set_client_cert(ctx->vpninfo, cert, sslkey);
release_cstring(ctx->jenv, jcert, cert);
release_cstring(ctx->jenv, jsslkey, sslkey);
return;
}
/* Reply to all queued requests.
*/
void flush_request_cb (flux_t h, flux_msg_handler_t *w,
const flux_msg_t *msg, void *arg)
{
ctx_t *ctx = getctx (h);
flux_msg_t *req;
while ((req = zlist_pop (ctx->clog_requests))) {
/* send clog response */
if (flux_respond (h, req, 0, NULL) < 0)
flux_log_error (h, "%s: flux_respond", __FUNCTION__);
}
/* send flush response */
if (flux_respond (h, msg, 0, NULL) < 0)
flux_log_error (h, "%s: flux_respond", __FUNCTION__);
}
/* special handling: multiple string arguments */
JNIEXPORT jint JNICALL Java_org_infradead_libopenconnect_LibOpenConnect_setupTunDevice(
JNIEnv *jenv, jobject jobj, jstring jarg0, jstring jarg1)
{
struct libctx *ctx = getctx(jenv, jobj);
const char *arg0 = NULL, *arg1 = NULL;
int ret = -ENOMEM;
if (ctx && !get_cstring(ctx->jenv, jarg0, &arg0) &&
!get_cstring(ctx->jenv, jarg1, &arg1))
ret = openconnect_setup_tun_device(ctx->vpninfo, arg0, arg1);
release_cstring(ctx->jenv, jarg0, arg0);
release_cstring(ctx->jenv, jarg1, arg1);
return ret;
}
