enum EVSFPrivopLoginResult
vsf_privop_do_login(struct vsf_session* p_sess,
const struct mystr* p_pass_str)
{
enum EVSFPrivopLoginResult result =
handle_login(p_sess, &p_sess->user_str, p_pass_str);
vsf_log_start_entry(p_sess, kVSFLogEntryLogin);
if (result == kVSFLoginFail)
{
vsf_log_do_log(p_sess, 0);
if (tunable_delay_failed_login)
{
vsf_sysutil_sleep((double) tunable_delay_failed_login);
}
}
else
{
vsf_log_do_log(p_sess, 1);
if (tunable_delay_successful_login)
{
vsf_sysutil_sleep((double) tunable_delay_successful_login);
}
}
return result;
}
void start_client() {
status = S_INIT;
while (true) {
switch(status) {
case S_INIT:
handle_init();
break;
case S_EXIT:
handle_exit();
return;
case S_LOGIN:
handle_login();
break;
case S_REGISTER:
handle_register();
break;
case S_VERIFIED:
handle_verified();
break;
case S_ORDER:
handle_order();
break;
case S_QUERY_ORDER:
handle_query_orders();
break;
case S_QUERY:
handle_query();
default:
break;
}
}
}
int pam_sm_open_session(pam_handle_t *pamh, int flags, int argc,
const char **argv)
{
const char *PAM_user = NULL;
int ret;
if (!cgm_dbus_connect()) {
mysyslog(LOG_ERR, "Failed to connect to cgmanager\n");
return PAM_SESSION_ERR;
}
if (argc > 1 && strcmp(argv[0], "-c") == 0)
ctrl_list = validate_and_dup(argv[1]);
if (!ctrl_list)
get_active_controllers();
cgm_escape();
ret = pam_get_user(pamh, &PAM_user, NULL);
if (ret != PAM_SUCCESS) {
cgm_dbus_disconnect();
mysyslog(LOG_ERR, "PAM-CGM: couldn't get user\n");
return PAM_SESSION_ERR;
}
ret = handle_login(PAM_user);
cgm_dbus_disconnect();
return ret;
}
gboolean
cockpit_handler_default (CockpitWebServer *server,
const gchar *path,
GHashTable *headers,
CockpitWebResponse *response,
CockpitHandlerData *data)
{
CockpitWebService *service;
const gchar *remainder = NULL;
gboolean resource;
path = cockpit_web_response_get_path (response);
g_return_val_if_fail (path != NULL, FALSE);
resource = g_str_has_prefix (path, "/cockpit/") ||
g_str_has_prefix (path, "/cockpit+") ||
g_str_equal (path, "/cockpit");
// Check for auth
service = cockpit_auth_check_cookie (data->auth, path, headers);
/* Stuff in /cockpit or /cockpit+xxx */
if (resource)
{
cockpit_web_response_skip_path (response);
remainder = cockpit_web_response_get_path (response);
if (!remainder)
{
cockpit_web_response_error (response, 404, NULL, NULL);
return TRUE;
}
else if (g_str_has_prefix (remainder, "/static/"))
{
cockpit_branding_serve (service, response, path, remainder + 8,
data->os_release, data->branding_roots);
return TRUE;
}
}
if (resource)
{
if (g_str_equal (remainder, "/login"))
{
handle_login (data, service, path, headers, response);
}
else
{
handle_resource (data, service, path, headers, response);
}
}
else
{
handle_shell (data, service, path, headers, response);
}
return TRUE;
}
enum EVSFPrivopLoginResult
vsf_privop_do_login(struct vsf_session* p_sess,
const struct mystr* p_pass_str)
{
enum EVSFPrivopLoginResult result =
handle_login(p_sess, &p_sess->user_str, p_pass_str);
vsf_log_start_entry(p_sess, kVSFLogEntryLogin);
if (result == kVSFLoginFail)
{
vsf_log_do_log(p_sess, 0);
}
else
{
vsf_log_do_log(p_sess, 1);
}
return result;
}
bool sockx::domsg(unsigned uicmd,unsigned int uilen,char* pbuff)
{
switch (uicmd)
{
case CMD_LOGIN:
return handle_login(pbuff,uilen,m_uiip,m_usport,m_isock);
break;
case CMD_LOG:
return handle_log(pbuff,uilen,m_uiip,m_usport,m_isock);
break;
case CMD_HEARTBEAT:
return handle_heartbeat(pbuff,uilen,m_uiip,m_usport,m_isock);
break;
default:
break;
}
return true;
}
static void filter_client_line(void)
{
int offset;
const char* cmd;
if (!handle_auth_response(&linebuf, 0)) {
if ((offset = parse_label()) > 0) {
cmd = linebuf.s + offset;
/* If we see a "AUTHENTICATE" or "LOGIN" command, save the preceding
* label for reference when looking for the corresponding "OK" */
if(!strncasecmp(cmd, "AUTHENTICATE ", 13)) {
if (handle_auth_parameter(&linebuf, offset + 13))
str_copy(&saved_label, &label);
}
else if (!strncasecmp(cmd, "LOGIN ", 6))
handle_login(offset + 6);
}
}
}
void serve_client(int fd, uint32_t events, user_list* lista) {
char *msg = 0;
size_t len = 0;
if (events & EPOLLIN) {
len = receive_msg(&msg, fd);
if (len > 0) {
if (msg[0] == '2') {
printf("%s\n", msg);
handle_login(msg, len, fd, lista);
} else if (msg[0] == '6') {
printf("%s\n", msg);
handle_user_list(msg, len, fd, lista);
}
}
//free(msg);
} else {
close(fd);
epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, 0);
//TODO remove from user list
}
}
int core::on_message(stream_handler* sh, inmessage* inmsg)
{
const uint16_t cmd = inmsg->command();
// not verified messages
switch (cmd) {
case cmd_peer_login:
handle_login(inmsg, sh);
}
peer* p = extract_peer(sh);
if (p == NULL) {
return -1;
}
// already verified messages
switch (cmd) {
case cmd_sock_close:
cleanup_and_del_peer(p, inmsg);
}
return 0;
}
/* parse client's order */
int parse_clnt_pack(SSL *ssl,SFT_PACK *clnt_pack,sqlite3 *db)
{
int ret = 0;
int n = order_isexist(clnt_pack->order);
if (n < 0)
{
fprintf(stderr,"%d:order is not exist!\n",clnt_pack->order);
return -1;
}
switch(clnt_pack->order)
{
case CIN: handle_login(ssl,clnt_pack,db);break;
case CREG: handle_register(ssl,clnt_pack,db);break;
case CMODIFY_PASSWD: handle_modify_passwd(ssl,clnt_pack,db);break;
case CSCS: handle_scan_dir(ssl,clnt_pack);break;
case CUP: handle_recv_file(ssl,clnt_pack);break;
case CDOWN: handle_send_file(ssl,clnt_pack);break;
case COUT: handle_logout(ssl,clnt_pack);
ret=COUT;break;
default: fprintf(stderr,"%d:null order:!\n",clnt_pack->order);
ret = -1;break;
}
return ret;
}
void client_service(int cli_fd, uint32_t events, int epoll_fd)
{
char *msg = 0;
size_t len = 0;
int if_clear_client = 1;
if (events & EPOLLIN) {
/* odczyt wiadomosci */
len = receive_msg(&msg, cli_fd);
if(len > 0) {
if(msg[0] =='2') {
if_clear_client = handle_login(msg, len, cli_fd);
}
else if(msg[0] == '6') {
if_clear_client = handle_userlist(msg, len, cli_fd);
}
}
}
if (if_clear_client) {
clear_client(cli_fd, epoll_fd);
}
}
