/* *Register */ int register_user(packet *in_pkt, int fd) { int i = 0; char *args[16]; char cpy[BUFFERSIZE]; char *tmp = cpy; strcpy(tmp, in_pkt->buf); args[i] = strsep(&tmp, " \t"); while ((i < sizeof(args) - 1) && (args[i] != '\0')) { args[++i] = strsep(&tmp, " \t"); } // Check there are enough arguements to safely inspect them if (i > 3) { // Ensure requested username is valid if (!validUsername(args[1], fd)) { return 0; } // Check if the requested username is unique if(strcmp(get_real_name(®istered_users_list, args[1], registered_users_mutex), "ERROR") !=0 || \ !(strcmp(SERVER_NAME, args[1])) || \ strcmp(args[2], args[3]) != 0) { sendError("Username unavailable.", fd); return 0; } // Ensure password requested is valid if (!validPassword(args[2], args[3], fd)) { return 0; } // Allocate memory space for new user node, populate node with new user data User *user = (User *)malloc(sizeof(User)); strcpy(user->username, args[1]); strcpy(user->real_name, args[1]); // Hash password SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, args[2], strlen(args[2])); SHA256_Final(user->password, &sha256); user->sock = fd; user->next = NULL; // Insert user as registered user, write new user data to file insertUser(®istered_users_list, user, registered_users_mutex); writeUserFile(®istered_users_list, USERS_FILE, registered_users_mutex); // Reform packet as valid login, pass new user data to login memset(&in_pkt->buf, 0, sizeof(in_pkt->buf)); sprintf(in_pkt->buf, "/login %s %s", args[1], args[2]); return login(in_pkt, fd); } // There were not enough arguements received to correctly read them else { printf("%s --- %sError:%s Malformed reg packet received from %s on %d, ignoring.\n", \ WHITE, RED, NORMAL, args[1], fd); } return 0; }
static void testpair(TALLOC_CTX *mem_ctx, struct smbcli_state *cli, char *mask, char *file) { int fnum; char res1[256]; char *res2; static int count; char *short_name = NULL; char *long_name = NULL; struct masktest_state state; count++; safe_strcpy(res1, "---", sizeof(res1)); state.mem_ctx = mem_ctx; fnum = smbcli_open(cli->tree, file, O_CREAT|O_TRUNC|O_RDWR, 0); if (fnum == -1) { DEBUG(0,("Can't create %s\n", file)); return; } smbcli_close(cli->tree, fnum); resultp = res1; short_name = talloc_strdup(mem_ctx, ""); get_real_name(mem_ctx, cli, &long_name, &short_name); safe_strcpy(res1, "---", sizeof(res1)); smbcli_list_new(cli->tree, mask, FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY, RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO, listfn, &state); res2 = reg_test(cli, mem_ctx, mask, long_name, short_name); if (showall || strcmp(res1, res2)) { d_printf("%s %s %d mask=[%s] file=[%s] rfile=[%s/%s]\n", res1, res2, count, mask, file, long_name, short_name); if (die_on_error) exit(1); } smbcli_unlink(cli->tree, file); if (count % 100 == 0) DEBUG(0,("%d\n", count)); resultp = NULL; }
/* *Get real name of user requested */ void user_lookup(packet *in_pkt, int fd) { int i = 0; char *args[16]; char *tmp = in_pkt->buf; args[i] = strsep(&tmp, " \t"); while ((i < sizeof(args) - 1) && (args[i] != '\0')) { args[++i] = strsep(&tmp, " \t"); } if (i > 1) { packet ret; ret.options = GETUSER; strcpy(ret.username, SERVER_NAME); strcpy(ret.realname, SERVER_NAME); char *realname = get_real_name(&active_users_list, args[1], active_users_mutex); if (strcmp(realname, "ERROR") == 0) { ret.options = SERV_ERR; sprintf(ret.buf, "%s not found.", args[1]); ret.timestamp = time(NULL); send(fd, &ret, sizeof(packet), MSG_NOSIGNAL); } else { sprintf(ret.buf, "User Lookup"); ret.timestamp = time(NULL); send(fd, &ret, sizeof(packet), MSG_NOSIGNAL); memset(&ret.buf, 0, sizeof(ret.buf)); strcpy(ret.buf, realname); sprintf(ret.buf, "%s-%s", args[1], realname); send(fd, &ret, sizeof(packet), MSG_NOSIGNAL); } } else { printf("%s --- Error:%s Malformed buffer received, ignoring.\n", RED, NORMAL); } }
static void list_session (GDBusConnection *connection, const char *ssid) { GDBusProxy *proxy; guint uid = 0; char *realname; char *sid; char *lsid; char *session_type; char *x11_display; char *x11_display_device; char *display_device; char *remote_host_name; char *creation_time; char *idle_since_hint; char *runtime_dir; gboolean is_active; gboolean is_local; char *short_sid; const char *short_ssid; GError *error = NULL; proxy = g_dbus_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, NULL, CK_NAME, ssid, CK_SESSION_INTERFACE, NULL, &error); if (proxy == NULL) { g_print ("error creating proxy, %s", error->message); g_clear_error (&error); return; } sid = NULL; lsid = NULL; session_type = NULL; x11_display = NULL; x11_display_device = NULL; display_device = NULL; remote_host_name = NULL; creation_time = NULL; idle_since_hint = NULL; get_uint (proxy, "GetUnixUser", &uid); get_path (proxy, "GetSeatId", &sid); get_string (proxy, "GetLoginSessionId", &lsid); get_string (proxy, "GetSessionType", &session_type); get_string (proxy, "GetX11Display", &x11_display); get_string (proxy, "GetX11DisplayDevice", &x11_display_device); get_string (proxy, "GetDisplayDevice", &display_device); get_string (proxy, "GetRemoteHostName", &remote_host_name); get_boolean (proxy, "IsActive", &is_active); get_boolean (proxy, "IsLocal", &is_local); get_string (proxy, "GetCreationTime", &creation_time); get_string (proxy, "GetIdleSinceHint", &idle_since_hint); get_string (proxy, "GetXDGRuntimeDir", &runtime_dir); realname = get_real_name (uid); short_sid = sid; short_ssid = ssid; if (g_str_has_prefix (sid, CK_PATH "/")) { short_sid = sid + strlen (CK_PATH) + 1; } if (g_str_has_prefix (ssid, CK_PATH "/")) { short_ssid = ssid + strlen (CK_PATH) + 1; } printf ("%s:\n\tunix-user = '******'\n\trealname = '%s'\n\tseat = '%s'\n\tsession-type = '%s'\n\tactive = %s\n\tx11-display = '%s'\n\tx11-display-device = '%s'\n\tdisplay-device = '%s'\n\tremote-host-name = '%s'\n\tis-local = %s\n\ton-since = '%s'\n\tlogin-session-id = '%s'\n\tXDG_RUNTIME_DIR = '%s'", short_ssid, uid, realname, short_sid, session_type, is_active ? "TRUE" : "FALSE", x11_display, x11_display_device, display_device, remote_host_name, is_local ? "TRUE" : "FALSE", creation_time, lsid, runtime_dir); if (idle_since_hint != NULL && idle_since_hint[0] != '\0') { printf ("\n\tidle-since-hint = '%s'", idle_since_hint); } printf ("\n"); g_free (idle_since_hint); g_free (creation_time); g_free (remote_host_name); g_free (realname); g_free (sid); g_free (lsid); g_free (session_type); g_free (x11_display); g_free (x11_display_device); g_free (display_device); g_free (runtime_dir); g_object_unref (proxy); }
int main(int argc, char *argv[]) { setlocale (LC_ALL, ""); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR); textdomain (GETTEXT_PACKAGE); gboolean explicit_username = FALSE; gboolean explicit_message = FALSE; int error = 0; int m = 0, i = 1; guint counter = 0; gchar *command = NULL; gchar *command_run = NULL; gchar *username = NULL; gchar *password = NULL; uid_t whoami; struct passwd *pw; char err_msg[256]; gchar *message = NULL; char **cmd_argv = NULL; GError *cmd_error = NULL; GtkWidget *dialog; GtkSizeGroup *sizegroup; GtkWidget *hbox; GtkWidget *image; GtkWidget *align; GtkWidget *label; GtkWidget *user; GtkWidget *pass; gtk_init(&argc, &argv); /* Parse arguments */ while (i < argc) { if (argv[i][0] != '-') break; if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h")) say_help(argv[0]); if (!strcmp(argv[i], "--version") || !strcmp(argv[i], "-v")) say_about(); if (!strcmp(argv[i], "--user") || !strcmp(argv[i], "-u")) { if ((username = argv[i + 1]) == NULL) Werror(ERR_MISSING_USER_AND_COMMAND, NULL, 1, 1); explicit_username = TRUE; i += 1; } if (!strcmp(argv[i], "--message") || !strcmp(argv[i], "-m")) { if ((message = argv[i + 1]) == NULL) Werror(ERR_MISSING_MESSAGE_AND_COMMAND, NULL, 1, 1); explicit_message = TRUE; i += 1; } i += 1; } if (argv[i] == NULL) Werror(ERR_MISSING_COMMAND, NULL, 1, 1); /* handle arguments and spaces in the subcommand correctly */ if (! g_shell_parse_argv(argv[i], NULL, &cmd_argv, &cmd_error)) /* Something bad has happened */ Werror(ERR_INVALID_COMMAND, cmd_error->message, 1, 1); /* Get the full path command */ command = get_real_name(cmd_argv[0]); if (command == NULL) Werror(ERR_INVALID_COMMAND, cmd_argv[0], 1, 1); /* Sanity check */ whoami = getuid(); if ((pw = getpwuid(whoami)) == NULL) exit(2 + 0 * fprintf(stderr, "Who you think you are? Houdini?\n")); if (!explicit_username) username = g_strdup("root"); if (username && !strcmp(pw->pw_name, username)) { /* username was me so let's just run it and get the hell out */ if (execvp(command, &(cmd_argv[0])) == -1) { Werror(ERR_PERMISSION_DENIED, NULL, 1, 1); exit(1); } /* We should never get here, but just in case */ exit(0); } if (explicit_username && !explicit_message) message = g_strdup_printf(gettext("Please enter the\npassword for %s:"), username); else if (!explicit_message) message = g_strdup(gettext("Please enter the desired\nusername and password:"******"ktsuss"); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), 5); gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog)->vbox), 5); hbox = gtk_hbox_new(FALSE, 6); #if GTK_CHECK_VERSION(2, 10, 0) image = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); #else image = gtk_image_new_from_icon_name("ktsuss", GTK_ICON_SIZE_DIALOG); #endif gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0); label = gtk_label_new(message); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox); sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); if (!explicit_username) { hbox = gtk_hbox_new(FALSE, 6); label = gtk_label_new(gettext("Username")); align = gtk_alignment_new(0, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(align), label); gtk_size_group_add_widget(sizegroup, align); gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, FALSE, 0); user = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(user), username ? username : "******"); gtk_box_pack_start(GTK_BOX(hbox), user, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox); } hbox = gtk_hbox_new(FALSE, 6); label = gtk_label_new(gettext("Password")); align = gtk_alignment_new(0, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(align), label); gtk_size_group_add_widget(sizegroup, align); gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, FALSE, 0); pass = gtk_entry_new_with_max_length(32); gtk_entry_set_visibility(GTK_ENTRY(pass), FALSE); gtk_box_pack_start(GTK_BOX(hbox), pass, FALSE, FALSE, 0); gtk_entry_set_activates_default(GTK_ENTRY(pass), TRUE); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); gtk_widget_grab_focus(pass); gtk_widget_show_all(GTK_DIALOG(dialog)->vbox); /* Show the dialog up to 3 times */ while (counter < 3) { if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { if (!explicit_username) username = strdup(gtk_entry_get_text(GTK_ENTRY(user))); password = strdup(gtk_entry_get_text(GTK_ENTRY(pass))); #ifdef SUDOPATH if ((error = check_password_sudo(username, password)) == ERR_SUCCESS) { #else if ((error = check_password_su(username, password)) == ERR_SUCCESS) { #endif gtk_widget_destroy(dialog); while (gtk_events_pending()) gtk_main_iteration(); dialog = NULL; /* using argv instead of cmd_argv is fine, because 'su' is going * to implement its only parsing nevertheless */ command_run = g_strjoinv(" ", &argv[i]); #ifdef SUDOPATH run_sudo(username, password, command_run); #else run_su(username, password, command_run); #endif g_free(command_run); counter = 3; } if (!explicit_username) { free(username); username = NULL; } memset(password, '\0', strlen(password)); free(password); if (error != ERR_SUCCESS) { snprintf(err_msg, sizeof(err_msg), gettext("Could not run '%s'"), command); Werror(error, err_msg, 0, 0); counter++; } } else break; if (counter < 3) gtk_widget_grab_focus(pass); } /* Clean up process */ if (dialog) gtk_widget_destroy(dialog); if ((explicit_username && !explicit_message) || !explicit_message) free(message); if (!explicit_username && username) g_free(username); g_strfreev(cmd_argv); if (cmd_error) g_error_free(cmd_error); return 0; }
/* *Login */ int login(packet *pkt, int fd) { int i = 0; char *args[16]; char cpy[BUFFERSIZE]; char *tmp = cpy; unsigned char *arg_pass_hash = (unsigned char *)malloc(SHA256_DIGEST); strcpy(tmp, pkt->buf); args[i] = strsep(&tmp, " \t"); while ((i < sizeof(args) - 1) && (args[i] != '\0')) { args[++i] = strsep(&tmp, " \t"); } // Check there are enough arguements to safely inspect them if (i > 2) { packet ret; // Check if user exists as registered user if (strcmp(get_real_name(®istered_users_list, args[1], registered_users_mutex), "ERROR") == 0) { sendError("Username not found.", fd); return 0; } // Retreive password for requested user unsigned char *password = get_password(®istered_users_list, args[1], registered_users_mutex); // Hash login password arg SHA256_CTX sha256; SHA256_Init(&sha256); SHA256_Update(&sha256, args[2], strlen(args[2])); SHA256_Final(arg_pass_hash, &sha256); // Compare pass arg and stored pass if (comparePasswords(password, arg_pass_hash, 32) != 0) { sendError("Incorrect password.", fd); free(arg_pass_hash); return 0; } free(arg_pass_hash); // Login input is valid, read user data from registered users User *user = get_user(®istered_users_list, args[1], registered_users_mutex); //Create node for active users list Node *new_usr_act = (Node *)malloc(sizeof(Node)); new_usr_act->data = (void *)user; new_usr_act->next = NULL; //Create node for room list Node *new_usr_rm = (Node *)malloc(sizeof(Node)); new_usr_rm->data = (void *)user; new_usr_rm->next = NULL; // Check if the user is already logged in if(insertUser(&active_users_list, user, active_users_mutex) == 1) { user->sock = fd; user->roomID = 1000; // Login successful, add user to default room Room *defaultRoom = Rget_roomFID(&room_list, DEFAULT_ROOM, rooms_mutex); insertNode(&(defaultRoom->user_list), new_usr_rm, defaultRoom->user_list_mutex); // Inform client of successful login strcpy(ret.realname, get_real_name(®istered_users_list, args[1], registered_users_mutex)); strcpy(ret.username, args[1]); ret.options = LOGSUC; //printf("%s logged in\n", ret.username); ret.timestamp = time(NULL); send(fd, &ret, sizeof(packet), MSG_NOSIGNAL); // Inform lobby of successful login memset(&ret, 0, sizeof(packet)); ret.options = DEFAULT_ROOM; strcpy(ret.realname, SERVER_NAME); strcpy(ret.username, SERVER_NAME); sprintf(ret.buf, "%s has joined the lobby.", user->real_name); ret.timestamp = time(NULL); send_message(&ret, -1); // Send MOTD to client sendMOTD(fd); return 1; } // Valid login data received, but user is already in active users else { sendError("User already logged in.", fd); printf("%s log in failed: already logged in", args[1]); free(user); return 0; } } // Not enough arguements received to properly parse input, ignore it else { printf("%s --- %sError:%s Malformed login packet received from %s on %d, ignoring.\n", \ WHITE, RED, NORMAL, args[1], fd); } return 0; }