Fix some more bugs in libsmbclient.c and add functionality to tree.c
[kai/samba.git] / source3 / client / tree.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 2.0
4    SMB client GTK+ tree-based application
5    Copyright (C) Andrew Tridgell 1998
6    Copyright (C) Richard Sharpe 2001
7    Copyright (C) John Terpstra 2001
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 /* example-gtk+ application, ripped off from the gtk+ tree.c sample */
25
26 #include <stdio.h>
27 #include <errno.h>
28 #include <gtk/gtk.h>
29 #include "libsmbclient.h"
30
31 /* for all the GtkItem:: and GtkTreeItem:: signals */
32 static void cb_itemsignal( GtkWidget *item,
33                            gchar     *signame )
34 {
35   GtkWidget *real_tree, *aitem, *subtree;
36   gchar *name;
37   GtkLabel *label;
38   gint dh, err, dirlen, level;
39   char dirbuf[512];
40   struct smbc_dirent *dirp;
41   
42   /* It's a Bin, so it has one child, which we know to be a
43      label, so get that */
44   label = GTK_LABEL (GTK_BIN (item)->child);
45   /* Get the text of the label */
46   gtk_label_get (label, &name);
47
48   level = GTK_TREE(item->parent)->level;
49
50   /* Get the level of the tree which the item is in */
51   g_print ("%s called for item %s->%p, level %d\n", signame, name,
52            item, GTK_TREE (item->parent)->level);
53
54   if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
55     char server[128];
56
57     if (level>0) {
58       gchar *sname;
59       GtkLabel *l2;
60       GtkWidget *p = GTK_WIDGET(item->parent);
61
62       p = GTK_TREE(p)->tree_owner;
63
64       l2 = GTK_LABEL(GTK_BIN(p)->child);
65
66       gtk_label_get(l2, &sname);
67       slprintf(server, 128, "smb://%s/%s", sname, name);
68
69     }
70     else
71       slprintf(server, 128, "smb://%s", name);
72
73     if ((dh = smbc_opendir(server)) < 0) { /* Handle error */
74
75       g_print("cb_wholenet: Could not open dir %s, %s\n", server, 
76               strerror(errno));
77
78       gtk_main_quit();
79
80       return;
81
82     }
83
84     real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
85
86     while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
87                                 sizeof(dirbuf))) != 0) {
88
89       if (err < 0) { /* An error, report it */
90
91         g_print("cb_wholenet: Could not read dir smbc://, %s\n",
92                 strerror(errno));
93
94         gtk_main_quit();
95
96         return;
97
98       }
99
100       dirp = (struct smbc_dirent *)dirbuf;
101
102       while (err > 0) {
103
104         dirlen = sizeof(struct smbc_dirent) + dirp->namelen +
105           dirp->commentlen + 1;
106
107         aitem = gtk_tree_item_new_with_label(dirp->name);
108
109         /* Connect all GtkItem:: and GtkTreeItem:: signals */
110         gtk_signal_connect (GTK_OBJECT(aitem), "select",
111                             GTK_SIGNAL_FUNC(cb_itemsignal), "select");
112         gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
113                             GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
114         gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
115                             GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
116         gtk_signal_connect (GTK_OBJECT(aitem), "expand",
117                             GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
118         gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
119                             GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
120         /* Add it to the parent tree */
121         gtk_tree_append (GTK_TREE(real_tree), aitem);
122         /* Show it - this can be done at any time */
123         gtk_widget_show (aitem);
124
125         fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
126
127         subtree = gtk_tree_new();
128
129         gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
130
131         (char *)dirp += dirlen;
132         err -= dirlen;
133
134       }
135
136     }
137
138     smbc_closedir(dh);   
139
140   }
141
142 }
143
144 /* Note that this is never called */
145 static void cb_unselect_child( GtkWidget *root_tree,
146                                GtkWidget *child,
147                                GtkWidget *subtree )
148 {
149   g_print ("unselect_child called for root tree %p, subtree %p, child %p\n",
150            root_tree, subtree, child);
151 }
152
153 /* Note that this is called every time the user clicks on an item,
154    whether it is already selected or not. */
155 static void cb_select_child (GtkWidget *root_tree, GtkWidget *child,
156                              GtkWidget *subtree)
157 {
158   g_print ("select_child called for root tree %p, subtree %p, child %p\n",
159            root_tree, subtree, child);
160 }
161
162 static void cb_selection_changed( GtkWidget *tree )
163 {
164   GList *i;
165   
166   g_print ("selection_change called for tree %p\n", tree);
167   g_print ("selected objects are:\n");
168
169   i = GTK_TREE_SELECTION(tree);
170   while (i){
171     gchar *name;
172     GtkLabel *label;
173     GtkWidget *item;
174
175     /* Get a GtkWidget pointer from the list node */
176     item = GTK_WIDGET (i->data);
177     label = GTK_LABEL (GTK_BIN (item)->child);
178     gtk_label_get (label, &name);
179     g_print ("\t%s on level %d\n", name, GTK_TREE
180              (item->parent)->level);
181     i = i->next;
182   }
183 }
184
185 /*
186  * Expand or collapse the whole network ...
187  */
188 static void cb_wholenet(GtkWidget *item, gchar *signame)
189 {
190   GtkWidget *real_tree, *aitem, *subtree;
191   gchar *name;
192   GtkLabel *label;
193   gint dh, err, dirlen;
194   char dirbuf[512];
195   struct smbc_dirent *dirp;
196   
197   label = GTK_LABEL (GTK_BIN (item)->child);
198   gtk_label_get (label, &name);
199   g_print ("%s called for item %s->%p, level %d\n", signame, name,
200            item, GTK_TREE (item->parent)->level);
201
202   if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
203
204     if ((dh = smbc_opendir("smb://")) < 0) { /* Handle error */
205
206       g_print("cb_wholenet: Could not open dir smbc://, %s\n",
207               strerror(errno));
208
209       gtk_main_quit();
210
211       return;
212
213     }
214
215     real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
216
217     while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
218                                 sizeof(dirbuf))) != 0) {
219
220       if (err < 0) { /* An error, report it */
221
222         g_print("cb_wholenet: Could not read dir smbc://, %s\n",
223                 strerror(errno));
224
225         gtk_main_quit();
226
227         return;
228
229       }
230
231       dirp = (struct smbc_dirent *)dirbuf;
232
233       while (err > 0) {
234
235         dirlen = sizeof(struct smbc_dirent) + dirp->namelen +
236           dirp->commentlen + 1;
237
238         aitem = gtk_tree_item_new_with_label(dirp->name);
239
240         /* Connect all GtkItem:: and GtkTreeItem:: signals */
241         gtk_signal_connect (GTK_OBJECT(aitem), "select",
242                             GTK_SIGNAL_FUNC(cb_itemsignal), "select");
243         gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
244                             GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
245         gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
246                             GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
247         gtk_signal_connect (GTK_OBJECT(aitem), "expand",
248                             GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
249         gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
250                             GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
251
252         gtk_tree_append (GTK_TREE(real_tree), aitem);
253         /* Show it - this can be done at any time */
254         gtk_widget_show (aitem);
255
256         fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
257
258         subtree = gtk_tree_new();
259
260         gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
261
262         (char *)dirp += dirlen;
263         err -= dirlen;
264
265       }
266
267     }
268
269     smbc_closedir(dh);   
270
271   }
272
273   /* Create this item's subtree */
274   /*  subtree = gtk_tree_new();
275   g_print ("-> item %s->%p, subtree %p\n", "Whole Network", item,
276            subtree);
277
278   /* This is still necessary if you want these signals to be called
279      for the subtree's children.  Note that selection_change will be 
280      signalled for the root tree regardless. */
281   /*  gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
282                       GTK_SIGNAL_FUNC(cb_select_child), subtree);
283     gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
284                         GTK_SIGNAL_FUNC(cb_unselect_child), subtree);
285     /* This has absolutely no effect, because it is completely ignored 
286        in subtrees */
287   /*    gtk_tree_set_selection_mode (GTK_TREE(subtree),
288                                  GTK_SELECTION_SINGLE);
289     /* Neither does this, but for a rather different reason - the
290        view_mode and view_line values of a tree are propagated to
291        subtrees when they are mapped.  So, setting it later on would
292        actually have a (somewhat unpredictable) effect */
293   /*    gtk_tree_set_view_mode (GTK_TREE(subtree), GTK_TREE_VIEW_ITEM);
294     /* Set this item's subtree - note that you cannot do this until
295        AFTER the item has been added to its parent tree! */
296   /*    gtk_tree_item_set_subtree (GTK_TREE_ITEM(item), subtree);
297
298     for (j = 0; j < 5; j++){
299       GtkWidget *subitem;
300
301       /* Create a subtree item, in much the same way */
302   /*      subitem = gtk_tree_item_new_with_label (itemnames[j]);
303       /* Connect all GtkItem:: and GtkTreeItem:: signals */
304   /*      gtk_signal_connect (GTK_OBJECT(subitem), "select",
305                           GTK_SIGNAL_FUNC(cb_itemsignal), "select");
306       gtk_signal_connect (GTK_OBJECT(subitem), "deselect",
307                           GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
308       gtk_signal_connect (GTK_OBJECT(subitem), "toggle",
309                           GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
310       gtk_signal_connect (GTK_OBJECT(subitem), "expand",
311                           GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
312       gtk_signal_connect (GTK_OBJECT(subitem), "collapse",
313                           GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
314       g_print ("-> -> item %s->%p\n", itemnames[j], subitem);
315       /* Add it to its parent tree */
316   /*      gtk_tree_append (GTK_TREE(subtree), subitem);
317       /* Show it */
318   /*      gtk_widget_show (subitem);
319     }
320   */
321 }
322
323 static void 
324 auth_fn(char *server, char *share,
325              char **workgroup, char **username, char **password)
326 {
327
328   *workgroup = "";
329   *username = "test";
330   *password = "test";
331
332 }
333
334 int main( int   argc,
335           char *argv[] )
336 {
337   GtkWidget *window, *scrolled_win, *tree;
338   GtkWidget *subtree, *item;
339   gint err, dh;
340   gint i;
341   char dirbuf[512];
342   struct smbc_dirent *dirp;
343
344   gtk_init (&argc, &argv);
345
346   /* Init the smbclient library */
347
348   err = smbc_init(auth_fn, "", 10);
349
350   /* a generic toplevel window */
351   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
352   gtk_signal_connect (GTK_OBJECT(window), "delete_event",
353                       GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
354   gtk_container_set_border_width (GTK_CONTAINER(window), 5);
355
356   /* A generic scrolled window */
357   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
358   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
359                                   GTK_POLICY_AUTOMATIC,
360                                   GTK_POLICY_AUTOMATIC);
361   gtk_widget_set_usize (scrolled_win, 150, 200);
362   gtk_container_add (GTK_CONTAINER(window), scrolled_win);
363   gtk_widget_show (scrolled_win);
364   
365   /* Create the root tree */
366   tree = gtk_tree_new();
367   g_print ("root tree is %p\n", tree);
368   /* connect all GtkTree:: signals */
369   gtk_signal_connect (GTK_OBJECT(tree), "select_child",
370                       GTK_SIGNAL_FUNC(cb_select_child), tree);
371   gtk_signal_connect (GTK_OBJECT(tree), "unselect_child",
372                       GTK_SIGNAL_FUNC(cb_unselect_child), tree);
373   gtk_signal_connect (GTK_OBJECT(tree), "selection_changed",
374                       GTK_SIGNAL_FUNC(cb_selection_changed), tree);
375   /* Add it to the scrolled window */
376   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled_win),
377                                          tree);
378   /* Set the selection mode */
379   gtk_tree_set_selection_mode (GTK_TREE(tree),
380                                GTK_SELECTION_MULTIPLE);
381   /* Show it */
382   gtk_widget_show (tree);
383
384   /* Now, build the top level display ... */
385
386   if ((dh = smbc_opendir("smb:///")) < 0) {
387
388     fprintf(stderr, "Could not list default workgroup: smb:///: %s\n",
389             strerror(errno));
390
391     exit(1);
392
393   }
394
395   /* Create a tree item for Whole Network */
396
397   item = gtk_tree_item_new_with_label ("Whole Network");
398   /* Connect all GtkItem:: and GtkTreeItem:: signals */
399   gtk_signal_connect (GTK_OBJECT(item), "select",
400                       GTK_SIGNAL_FUNC(cb_itemsignal), "select");
401   gtk_signal_connect (GTK_OBJECT(item), "deselect",
402                       GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
403   gtk_signal_connect (GTK_OBJECT(item), "toggle",
404                       GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
405   gtk_signal_connect (GTK_OBJECT(item), "expand",
406                       GTK_SIGNAL_FUNC(cb_wholenet), "expand");
407   gtk_signal_connect (GTK_OBJECT(item), "collapse",
408                       GTK_SIGNAL_FUNC(cb_wholenet), "collapse");
409   /* Add it to the parent tree */
410   gtk_tree_append (GTK_TREE(tree), item);
411   /* Show it - this can be done at any time */
412   gtk_widget_show (item);
413
414   subtree = gtk_tree_new();  /* A subtree for Whole Network */
415
416   gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
417
418   /* Now, get the items in smb:/// and add them to the tree */
419
420   dirp = (struct smbc_dirent *)dirbuf;
421
422   while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
423                               sizeof(dirbuf))) != 0) {
424
425     if (err < 0) { /* Handle the error */
426
427       fprintf(stderr, "Could not read directory for smbc:///: %s\n",
428               strerror(errno));
429
430       exit(1);
431
432     }
433
434     fprintf(stdout, "Dir len: %u\n", err);
435
436     while (err > 0) { /* Extract each entry and make a sub-tree */
437
438       int dirlen = sizeof(struct smbc_dirent) + dirp->namelen + 
439         dirp->commentlen + 1;
440
441       item = gtk_tree_item_new_with_label(dirp->name);
442       /* Connect all GtkItem:: and GtkTreeItem:: signals */
443       gtk_signal_connect (GTK_OBJECT(item), "select",
444                           GTK_SIGNAL_FUNC(cb_itemsignal), "select");
445       gtk_signal_connect (GTK_OBJECT(item), "deselect",
446                           GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
447       gtk_signal_connect (GTK_OBJECT(item), "toggle",
448                           GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
449       gtk_signal_connect (GTK_OBJECT(item), "expand",
450                           GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
451       gtk_signal_connect (GTK_OBJECT(item), "collapse",
452                           GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
453       /* Add it to the parent tree */
454       gtk_tree_append (GTK_TREE(tree), item);
455       /* Show it - this can be done at any time */
456       gtk_widget_show (item);
457
458       fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
459
460       subtree = gtk_tree_new();
461
462       gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
463
464       (char *)dirp += dirlen;
465       err -= dirlen;
466
467     }
468
469   }
470
471   smbc_closedir(dh); /* FIXME, check for error :-) */
472
473   /* Show the window and loop endlessly */
474   gtk_widget_show (window);
475   gtk_main();
476   return 0;
477 }
478 /* example-end */