Logo Search packages:      
Sourcecode: samba-gtk version File versions  Download package

gwsam.c

/* 
   Unix SMB/CIFS implementation.
   GTK+ SAM frontend
   
   Copyright (C) Jelmer Vernooij 2004

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <stdbool.h>
#include <gen_ndr/ndr_samr_c.h>
#include "common/select.h"
#include "common/gtk-smb.h"
#include <credentials.h>
#include <param.h>
#include <tevent.h>
#include <util/debug.h>

struct policy_handle sam_handle;
struct dcerpc_binding_handle *sam_pipe = NULL;
static struct policy_handle domain_handle;
GtkWidget *mainwin;
GtkWidget *seldomain;
GtkListStore *store_users;
GtkListStore *store_groups;
static GtkWidget *mnu_disconnect;
struct loadparm_context *lp_ctx;
struct tevent_context *ev_ctx;

static void update_grouplist(void)
{
      if(!sam_pipe) return;
      //FIXME
}

static void update_userlist(void)
{
      NTSTATUS status, result;
      struct samr_SamArray *sam;
      uint32_t resume_handle=0;
      uint32_t num_entries;
      int i;
      TALLOC_CTX *mem_ctx;

      if(!sam_pipe) return;

      gtk_list_store_clear(store_users);

      mem_ctx = talloc_init("update_userlist");

      status = dcerpc_samr_EnumDomainUsers(sam_pipe, mem_ctx, &domain_handle,
                                                             &resume_handle, 0, &sam, 100,
                                                             &num_entries, &result);
      if (!NT_STATUS_IS_OK(status)) {
            gtk_show_ntstatus(mainwin, "While enumerating domain users", status);
            talloc_free(mem_ctx);
            return;
      }

      if (!sam || sam->count == 0) {
            talloc_free(mem_ctx);
            return;
      }

      for (i=0;i<sam->count;i++) {
                GtkTreeIter iter;
                gtk_list_store_append(store_users, &iter);
                gtk_list_store_set (store_users, &iter, 
                  0, sam->entries[i].name.string,
                  1, sam->entries[i].name.string,
                  2, 0, -1);

            /* FIXME: Query user info */

            //          if (!test_OpenUser(sam_pipe, mem_ctx, &sam_handle, sam->entries[i].idx)) {
            //                ret = false;
            //          }
      }
      talloc_free(mem_ctx);
}

static void on_new1_activate(GtkMenuItem *menuitem, gpointer user_data)
{
      /* FIXME */
}

static void on_select_domain_activate(GtkMenuItem *menuitem, gpointer user_data)
{
      GtkSelectDomainDialog *d;
      gint result;
      d = GTK_SELECT_DOMAIN_DIALOG(gtk_select_domain_dialog_new(sam_pipe));
      result = gtk_dialog_run(GTK_DIALOG(d));
      switch(result) {
      case GTK_RESPONSE_OK:
            break;
      default:
            gtk_widget_destroy(GTK_WIDGET(d));
            return;
      }
      domain_handle = gtk_select_domain_dialog_get_handle(d);

      update_userlist();
      update_grouplist();

      gtk_widget_destroy(GTK_WIDGET(d));
}

static void connect_sam(void)
{
      TALLOC_CTX *mem_ctx;
      NTSTATUS status, result;

      mem_ctx = talloc_init("gwsam_connect");

      sam_pipe = gtk_connect_rpc_interface(talloc_autofree_context(), ev_ctx, 
                                                             lp_ctx, &ndr_table_samr);

      if (!sam_pipe)
            return;

      status = dcerpc_samr_Connect(sam_pipe, mem_ctx, 0, SEC_FLAG_MAXIMUM_ALLOWED,
                                                 &sam_handle, &result);
      if (!NT_STATUS_IS_OK(status)) {
            gtk_show_ntstatus(mainwin, "While running connect on SAMR", status);
            sam_pipe = NULL;
            talloc_free(mem_ctx);
            return;
      }

      gtk_widget_set_sensitive (seldomain, TRUE);
      gtk_widget_set_sensitive (mnu_disconnect, TRUE);

      sam_pipe = talloc_reference(talloc_autofree_context(), sam_pipe);
      talloc_free(mem_ctx);
}

static void on_connect_activate (GtkMenuItem *menuitem, gpointer user_data)
{
      connect_sam();
      /* FIXME: Connect to default domain */
}

static void on_disconnect_activate (GtkMenuItem *menuitem, gpointer user_data)
{
      gtk_widget_set_sensitive (mnu_disconnect, FALSE);
}

static void on_quit_activate (GtkMenuItem *menuitem, gpointer user_data)
{
      talloc_free(sam_pipe);

      gtk_main_quit();
}

static void on_account_activate(GtkMenuItem *menuitem, gpointer user_data)
{
      //FIXME
}


static void on_user_rights_activate(GtkMenuItem *menuitem, gpointer user_data)
{
      //FIXME
}


static void on_audit_activate(GtkMenuItem *menuitem, gpointer user_data)
{
      //FIXME
}


static void on_trust_relations_activate(GtkMenuItem *menuitem, gpointer user_data)
{
      //FIXME
}


static void on_refresh_activate(GtkMenuItem *menuitem, gpointer user_data)
{
      update_userlist();
      update_grouplist();
}


static void on_about_activate(GtkMenuItem *menuitem, gpointer user_data)
{
      GtkDialog *aboutwin = GTK_DIALOG(create_gtk_samba_about_dialog("gwsam"));
      gtk_dialog_run(aboutwin);
      gtk_widget_destroy(GTK_WIDGET(aboutwin));
}

static GtkWidget* create_mainwindow (void)
{
      GtkWidget *vbox1;
      GtkWidget *mnu_connect;
      GtkWidget *menubar;
      GtkWidget *menuitem1;
      GtkWidget *menuitem1_menu;
      GtkWidget *new1;
      GtkWidget *separatormenuitem1;
      GtkWidget *quit;
      GtkCellRenderer *renderer;
      GtkTreeViewColumn *curcol;
      GtkWidget *policies;
      GtkWidget *policies_menu;
      GtkWidget *account;
      GtkWidget *user_rights;
      GtkWidget *audit;
      GtkWidget *separator1;
      GtkWidget *trust_relations;
      GtkWidget *menuitem3;
      GtkWidget *menuitem3_menu;
      GtkWidget *refresh;
      GtkWidget *menuitem4;
      GtkWidget *menuitem4_menu;
      GtkWidget *about;
      GtkWidget *vpaned;
      GtkWidget *scrolledwindow1;
      GtkWidget *user_list;
      GtkWidget *scrolledwindow2;
      GtkWidget *group_list;
      GtkWidget *statusbar;
      GtkAccelGroup *accel_group;

      accel_group = gtk_accel_group_new ();

      mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_default_size (GTK_WINDOW (mainwin), 642, 562);
      gtk_window_set_title (GTK_WINDOW (mainwin), "User Manager");

      vbox1 = gtk_vbox_new (FALSE, 0);
      gtk_container_add (GTK_CONTAINER (mainwin), vbox1);

      menubar = gtk_menu_bar_new ();
      gtk_box_pack_start (GTK_BOX (vbox1), menubar, FALSE, FALSE, 0);

      menuitem1 = gtk_menu_item_new_with_mnemonic ("_File");
      gtk_container_add (GTK_CONTAINER (menubar), menuitem1);

      menuitem1_menu = gtk_menu_new ();
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem1), menuitem1_menu);

      mnu_connect = gtk_menu_item_new_with_mnemonic ("_Connect");
      gtk_container_add (GTK_CONTAINER (menuitem1_menu), mnu_connect);

      mnu_disconnect = gtk_menu_item_new_with_mnemonic ("_Disconnect");
      gtk_widget_set_sensitive (mnu_disconnect, FALSE);
      gtk_container_add (GTK_CONTAINER (menuitem1_menu), mnu_disconnect);

      seldomain = gtk_menu_item_new_with_mnemonic("_Select Domain");
      gtk_widget_set_sensitive (seldomain, FALSE);
      gtk_container_add (GTK_CONTAINER (menuitem1_menu), seldomain);

      separatormenuitem1 = gtk_separator_menu_item_new ();
      gtk_container_add (GTK_CONTAINER (menuitem1_menu), separatormenuitem1);
      gtk_widget_set_sensitive (separatormenuitem1, FALSE);

      quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
      gtk_container_add (GTK_CONTAINER (menuitem1_menu), quit);

      menuitem1 = gtk_menu_item_new_with_mnemonic ("_User");
      gtk_container_add (GTK_CONTAINER (menubar), menuitem1);
      gtk_widget_set_sensitive (menuitem1, FALSE);

      menuitem1_menu = gtk_menu_new ();
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem1), menuitem1_menu);

      new1 = gtk_image_menu_item_new_from_stock ("gtk-new", accel_group);
      gtk_container_add (GTK_CONTAINER (menuitem1_menu), new1);

      policies = gtk_menu_item_new_with_mnemonic ("_Policies");
      gtk_container_add (GTK_CONTAINER (menubar), policies);
      gtk_widget_set_sensitive (policies, FALSE);

      policies_menu = gtk_menu_new ();
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (policies), policies_menu);

      account = gtk_menu_item_new_with_mnemonic ("_Account...");
      gtk_container_add (GTK_CONTAINER (policies_menu), account);

      user_rights = gtk_menu_item_new_with_mnemonic ("_User Rights...");
      gtk_container_add (GTK_CONTAINER (policies_menu), user_rights);

      audit = gtk_menu_item_new_with_mnemonic ("A_udit...");
      gtk_container_add (GTK_CONTAINER (policies_menu), audit);

      separator1 = gtk_separator_menu_item_new ();
      gtk_container_add (GTK_CONTAINER (policies_menu), separator1);
      gtk_widget_set_sensitive (separator1, FALSE);

      trust_relations = gtk_menu_item_new_with_mnemonic ("_Trust relations");
      gtk_container_add (GTK_CONTAINER (policies_menu), trust_relations);

      menuitem3 = gtk_menu_item_new_with_mnemonic ("_View");
      gtk_container_add (GTK_CONTAINER (menubar), menuitem3);

      menuitem3_menu = gtk_menu_new ();
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem3), menuitem3_menu);

      refresh = gtk_image_menu_item_new_from_stock ("gtk-refresh", accel_group);
      gtk_container_add (GTK_CONTAINER (menuitem3_menu), refresh);
      gtk_widget_set_sensitive (refresh, FALSE);

      menuitem4 = gtk_menu_item_new_with_mnemonic ("_Help");
      gtk_container_add (GTK_CONTAINER (menubar), menuitem4);

      menuitem4_menu = gtk_menu_new ();
      gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem4), menuitem4_menu);

      about = gtk_menu_item_new_with_mnemonic ("_About");
      gtk_container_add (GTK_CONTAINER (menuitem4_menu), about);

      vpaned = gtk_vpaned_new ();
      gtk_box_pack_start (GTK_BOX (vbox1), vpaned, TRUE, TRUE, 0);

      scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
      gtk_paned_pack1 (GTK_PANED (vpaned), scrolledwindow1, FALSE, TRUE);

      user_list = gtk_tree_view_new ();
      gtk_container_add (GTK_CONTAINER (scrolledwindow1), user_list);

      curcol = gtk_tree_view_column_new();
      gtk_tree_view_column_set_title(curcol, "Name");
      renderer = gtk_cell_renderer_text_new();
      gtk_tree_view_column_pack_start(curcol, renderer, true);
      gtk_tree_view_append_column(GTK_TREE_VIEW(user_list), curcol);
      gtk_tree_view_column_add_attribute(curcol, renderer, "text", 0);

      curcol = gtk_tree_view_column_new();
      gtk_tree_view_column_set_title(curcol, "Description");
      renderer = gtk_cell_renderer_text_new();
      gtk_tree_view_column_pack_start(curcol, renderer, true);
      gtk_tree_view_append_column(GTK_TREE_VIEW(user_list), curcol);
      gtk_tree_view_column_add_attribute(curcol, renderer, "text", 1);

      curcol = gtk_tree_view_column_new();
      gtk_tree_view_column_set_title(curcol, "RID");
      renderer = gtk_cell_renderer_text_new();
      gtk_tree_view_column_pack_start(curcol, renderer, true);
      gtk_tree_view_append_column(GTK_TREE_VIEW(user_list), curcol);
      gtk_tree_view_column_add_attribute(curcol, renderer, "text", 1);

      store_users = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
      gtk_tree_view_set_model(GTK_TREE_VIEW(user_list), GTK_TREE_MODEL(store_users));

      scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
      gtk_paned_pack2 (GTK_PANED (vpaned), scrolledwindow2, TRUE, TRUE);

      group_list = gtk_tree_view_new ();
      gtk_container_add (GTK_CONTAINER (scrolledwindow2), group_list);

      curcol = gtk_tree_view_column_new();
      gtk_tree_view_column_set_title(curcol, "Name");
      renderer = gtk_cell_renderer_text_new();
      gtk_tree_view_column_pack_start(curcol, renderer, true);
      gtk_tree_view_append_column(GTK_TREE_VIEW(group_list), curcol);
      gtk_tree_view_column_add_attribute(curcol, renderer, "text", 0);

      curcol = gtk_tree_view_column_new();
      gtk_tree_view_column_set_title(curcol, "Description");
      renderer = gtk_cell_renderer_text_new();
      gtk_tree_view_column_pack_start(curcol, renderer, true);
      gtk_tree_view_append_column(GTK_TREE_VIEW(group_list), curcol);
      gtk_tree_view_column_add_attribute(curcol, renderer, "text", 1);

      curcol = gtk_tree_view_column_new();
      gtk_tree_view_column_set_title(curcol, "RID");
      renderer = gtk_cell_renderer_text_new();
      gtk_tree_view_column_pack_start(curcol, renderer, true);
      gtk_tree_view_append_column(GTK_TREE_VIEW(group_list), curcol);
      gtk_tree_view_column_add_attribute(curcol, renderer, "text", 1);

      store_groups = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
      gtk_tree_view_set_model(GTK_TREE_VIEW(group_list), GTK_TREE_MODEL(store_groups));

      statusbar = gtk_statusbar_new ();
      gtk_box_pack_start (GTK_BOX (vbox1), statusbar, FALSE, FALSE, 0);

      g_signal_connect ((gpointer) new1, "activate",
                                G_CALLBACK (on_new1_activate),
                                NULL);
      g_signal_connect ((gpointer) seldomain, "activate",
                                G_CALLBACK (on_select_domain_activate),
                                NULL);
      g_signal_connect ((gpointer) mnu_connect, "activate",
                                G_CALLBACK (on_connect_activate),
                                NULL);
      g_signal_connect ((gpointer) mnu_disconnect, "activate",
                                G_CALLBACK (on_disconnect_activate),
                                NULL);
      g_signal_connect ((gpointer) quit, "activate",
                                G_CALLBACK (on_quit_activate),
                                NULL);
      g_signal_connect ((gpointer) account, "activate",
                                G_CALLBACK (on_account_activate),
                                NULL);
      g_signal_connect ((gpointer) user_rights, "activate",
                                G_CALLBACK (on_user_rights_activate),
                                NULL);
      g_signal_connect ((gpointer) audit, "activate",
                                G_CALLBACK (on_audit_activate),
                                NULL);
      g_signal_connect ((gpointer) trust_relations, "activate",
                                G_CALLBACK (on_trust_relations_activate),
                                NULL);
      g_signal_connect ((gpointer) refresh, "activate",
                                G_CALLBACK (on_refresh_activate),
                                NULL);
      g_signal_connect ((gpointer) about, "activate",
                                G_CALLBACK (on_about_activate),
                                NULL);

      gtk_window_add_accel_group (GTK_WINDOW (mainwin), accel_group);

      return mainwin;
}

int main(int argc, char **argv)
{
      lp_ctx = loadparm_init(NULL);
      lpcfg_load_default(lp_ctx);
      setup_logging(argv[0], DEBUG_STDERR);

      dcerpc_init(lp_ctx);

      ev_ctx = tevent_context_init(lp_ctx);
      gtk_init(&argc, &argv);
      mainwin = create_mainwindow();
      gtk_widget_show_all(mainwin);

      return gtk_event_loop();
}

Generated by  Doxygen 1.6.0   Back to index