/*
*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;
}