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