Example #1
0
// When a thread exits, we also want to free its hashtable. We don't want to free the hashtable if we are just
// reinitializing the thread, since we want to keep the health status that causes those reinitializations
static void session_destroy(void *s) {
    pthread_mutex_lock(&saint_state_mutex);
    try_release_request_outstanding();
    pthread_mutex_unlock(&saint_state_mutex);
    session_cleanup(s);
    g_hash_table_destroy(node_status.node_hash_table);
}
Example #2
0
static void cli_dropbear_exit(int exitcode, const char* format, va_list param) {

	char fmtbuf[300];
	char exitmsg[500];

	if (!sessinitdone) {
		snprintf(fmtbuf, sizeof(fmtbuf), "Exited: %s",
				format);
	} else {
		snprintf(fmtbuf, sizeof(fmtbuf), 
				"Connection to %s@%s:%s exited: %s", 
				cli_opts.username, cli_opts.remotehost, 
				cli_opts.remoteport, format);
	}

	/* Arguments to the exit printout may be unsafe to use after session_cleanup() */
	vsnprintf(exitmsg, sizeof(exitmsg), fmtbuf, param);

	/* Do the cleanup first, since then the terminal will be reset */
	session_cleanup();
	/* Avoid printing onwards from terminal cruft */
	fprintf(stderr, "\n");

	dropbear_log(LOG_INFO, "%s", exitmsg);;
	exit(exitcode);
}
Example #3
0
static void cli_dropbear_exit(int exitcode, const char* format, va_list param) {
	char exitmsg[150];
	char fullmsg[300];

	/* Note that exit message must be rendered before session cleanup */

	/* Render the formatted exit message */
	vsnprintf(exitmsg, sizeof(exitmsg), format, param);

	/* Add the prefix depending on session/auth state */
	if (!sessinitdone) {
		snprintf(fullmsg, sizeof(fullmsg), "Exited: %s", exitmsg);
	} else {
		snprintf(fullmsg, sizeof(fullmsg), 
				"Connection to %s@%s:%s exited: %s", 
				cli_opts.username, cli_opts.remotehost, 
				cli_opts.remoteport, exitmsg);
	}

	/* Do the cleanup first, since then the terminal will be reset */
	session_cleanup();
	/* Avoid printing onwards from terminal cruft */
	fprintf(stderr, "\n");

	dropbear_log(LOG_INFO, "%s", fullmsg);
	exit(exitcode);
}
Example #4
0
/* failure exit - format must be <= 100 chars */
static void _dropbear_exit(int exitcode, const char* format, va_list param) {

	char fmtbuf[200];

	if (!sessinitdone) {
		/* before session init */
		snprintf(fmtbuf, sizeof(fmtbuf), 
				"premature exit: %s", format);
	} else if (ses.authstate.authdone) {
		/* user has authenticated */
		snprintf(fmtbuf, sizeof(fmtbuf),
				"exit after auth (%s): %s", 
				ses.authstate.printableuser, format);
	} else if (ses.authstate.printableuser) {
		/* we have a potential user */
		snprintf(fmtbuf, sizeof(fmtbuf), 
				"exit before auth (user '%s', %d fails): %s",
				ses.authstate.printableuser, ses.authstate.failcount, format);
	} else {
		/* before userauth */
		snprintf(fmtbuf, sizeof(fmtbuf), 
				"exit before auth: %s", format);
	}

	_dropbear_log(LOG_INFO, fmtbuf, param);

	/* must be after using username etc */
	session_cleanup();

	exit(exitcode);

}
Example #5
0
/* failure exit - format must be <= 100 chars */
static void _dropbear_exit(int exitcode, const char* format, va_list param) {

	char fmtbuf[200];

	if (!sessinitdone) {
		/* before session init */
		snprintf(fmtbuf, sizeof(fmtbuf), "exited: %s", format);
	} else if (ses.authstate.authdone) {
		/* user has authenticated */
		snprintf(fmtbuf, sizeof(fmtbuf),
				"exited after userauth (%s) from %s: %s", 
				ses.authstate.printableuser, ses.addrstring, format);
	} else {
		/* before userauth */
		snprintf(fmtbuf, sizeof(fmtbuf), "exited before userauth: %s",
				format);
	}

// brcm commented next line
   //_dropbear_log(LOG_INFO, fmtbuf, param);

	/* must be after using username etc */
	session_cleanup();

	exit(exitcode);

}
Example #6
0
static void delete_session(CURL *session, bool tmp_session) {
    log_print(LOG_INFO, SECTION_SESSION_DEFAULT, "delete_session: destroying old handle and creating a new one");
    if (tmp_session) {
        delete_tmp_session(session);
    }
    else {
        session_cleanup(session);
    }
}
Example #7
0
/* failure exit - format must be <= 100 chars */
void svr_dropbear_exit(int exitcode, const char* format, va_list param) {

	char fmtbuf[300];
	int i;

	if (!sessinitdone) {
		/* before session init */
		snprintf(fmtbuf, sizeof(fmtbuf), 
				"Early exit: %s", format);
	} else if (ses.authstate.authdone) {
		/* user has authenticated */
		snprintf(fmtbuf, sizeof(fmtbuf),
				"Exit (%s): %s", 
				ses.authstate.pw_name, format);
	} else if (ses.authstate.pw_name) {
		/* we have a potential user */
		snprintf(fmtbuf, sizeof(fmtbuf), 
				"Exit before auth (user '%s', %d fails): %s",
				ses.authstate.pw_name, ses.authstate.failcount, format);
	} else {
		/* before userauth */
		snprintf(fmtbuf, sizeof(fmtbuf), 
				"Exit before auth: %s", format);
	}

	_dropbear_log(LOG_INFO, fmtbuf, param);

#ifdef USE_VFORK
	/* For uclinux only the main server process should cleanup - we don't want
	 * forked children doing that */
	if (svr_ses.server_pid == getpid())
#endif
	{
		/* must be after we've done with username etc */
		session_cleanup();
	}

	if (svr_opts.hostkey) {
		sign_key_free(svr_opts.hostkey);
		svr_opts.hostkey = NULL;
	}
	for (i = 0; i < DROPBEAR_MAX_PORTS; i++) {
		m_free(svr_opts.addresses[i]);
		m_free(svr_opts.ports[i]);
	}

	exit(exitcode);

}
Example #8
0
static CURL *update_session(bool tmp_session) {
    static const char *funcname = "update_session";
    CURL *session = NULL;

    // We only need a new addr_table if we need a new session, and if we call update_session,
    // we need a new session
    GHashTable *addr_table;
    addr_table = create_new_addr_table();
    // On getaddrinfo failure, NULL gets returned; pass it through
    if (addr_table == NULL) return NULL;

    // create the hash table of node addresses for which we will keep health status
    // We do this when the thread is initialized. We want the hashtable to survive reinitialization of the handle,
    // since the hashtable keeps track of the health status of connections causing the reinitialization

    log_print(LOG_INFO, SECTION_SESSION_DEFAULT, "Opening cURL session");

    // if tmp_session, we need to get a new session for this request; otherwise see if we already have a session
    if (!tmp_session) {
        session = pthread_getspecific(session_tsd_key);
        if (session) {
            log_print(LOG_CRIT, SECTION_SESSION_DEFAULT, "%s: Got unexpected already-existing session; deleting: %p", funcname, session);
            session_cleanup(session);
        }
    }

    session = curl_easy_init();
    if (!session) {
        log_print(LOG_CRIT, SECTION_SESSION_DEFAULT, "%s: curl_easy_init returns NULL", funcname);
        return NULL;
    }
    // We don't want a tmp session to muck with start time and resetting the main session
    if (!tmp_session) {
        // Keep track of start time so we can track how long sessions stay open
        session_start_time = time(NULL);
        pthread_setspecific(session_tsd_key, session);
        log_print(LOG_INFO, SECTION_SESSION_DEFAULT, "%s: new session: %p", funcname, session);
        update_session_count(true);
    }

    log_print(LOG_DEBUG, SECTION_SESSION_DEFAULT, "%s: construct_resolve_slist: addr_table (%p)", funcname, addr_table);
    construct_resolve_slist(addr_table);
    g_hash_table_destroy(addr_table);

    return session;
}
Example #9
0
void cleanup(void)
{
    msg_log(MSG_MESSAGE, "Cleanup...\n");
    session_cleanup();
    dish_file_state_cleanup();
    midi_stop();
    driver_stop();
    patch_shutdown();
    mixer_shutdown();
    settings_write();
    settings_free();
    free_instance_name();
    mod_src_destroy();

    msg_log(MSG_MESSAGE, "Goodbye!\n");

    exit(0);
}
Example #10
0
static bool needs_new_session(bool tmp_session) {
    CURL *session;
    const char *funcname = "needs_new_session";
    bool new_session = false;

    // Short circuit on tmp_session; we always need a new session
    if (tmp_session) {
        log_print(LOG_INFO, SECTION_SESSION_DEFAULT, "%s: tmp_session is true", funcname);
        return true;
    }

    // session is null
    pthread_once(&session_once, session_tsd_key_init);

    session = pthread_getspecific(session_tsd_key);
    log_print(LOG_DEBUG, SECTION_SESSION_DEFAULT, "%s?: session (%p)", funcname, session);

    if (!session) {
        log_print(LOG_NOTICE, SECTION_SESSION_DEFAULT, "%s: !session", funcname);
        new_session = true;
    }

    // no slist
    else if (!valid_slist()) {
        log_print(LOG_NOTICE, SECTION_SESSION_DEFAULT, "%s: !valid_slist", funcname);
        new_session = true;
    }

    // timeout
    else if (slist_timed_out()) {
        log_print(LOG_INFO, SECTION_SESSION_DEFAULT, "%s: slist_timed_out", funcname);
        new_session = true;
    }

    // We're going to create a new session, so get rid of the old
    if (new_session) {
        session_cleanup(session);
    }

    return new_session;
}
Example #11
0
static void cli_dropbear_exit(int exitcode, const char* format, va_list param) {

	char fmtbuf[300];

	if (!sessinitdone) {
		snprintf(fmtbuf, sizeof(fmtbuf), "Exited: %s",
				format);
	} else {
		snprintf(fmtbuf, sizeof(fmtbuf), 
				"Connection to %s@%s:%s exited: %s", 
				cli_opts.username, cli_opts.remotehost, 
				cli_opts.remoteport, format);
	}

	/* Do the cleanup first, since then the terminal will be reset */
	session_cleanup();

	_dropbear_log(LOG_INFO, fmtbuf, param);

	exit(exitcode);
}