Fix some problems with tree.c reported by users.
[samba.git] / examples / libsmbclient / 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 static GtkWidget *clist;
32
33 struct tree_data {
34
35   guint32 type;    /* Type of tree item, an SMBC_TYPE */
36   char name[256];  /* May need to change this later   */
37
38 };
39
40 void error_message(gchar *message) {
41
42   GtkWidget *dialog, *label, *okay_button;
43      
44   /* Create the widgets */
45      
46   dialog = gtk_dialog_new();
47   gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
48   label = gtk_label_new (message);
49   okay_button = gtk_button_new_with_label("Okay");
50      
51   /* Ensure that the dialog box is destroyed when the user clicks ok. */
52      
53   gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
54                              GTK_SIGNAL_FUNC (gtk_widget_destroy), 
55                              GTK_OBJECT(dialog));
56   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
57                      okay_button);
58
59   /* Add the label, and show everything we've added to the dialog. */
60
61   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
62                      label);
63   gtk_widget_show_all (dialog);
64 }
65
66 /*
67  * We are given a widget, and we want to retrieve its URL so we 
68  * can do a directory listing.
69  *
70  * We walk back up the tree, picking up pieces until we hit a server or
71  * workgroup type and return a path from there
72  */
73
74 static char path_string[1024];
75
76 char *get_path(GtkWidget *item)
77 {
78   GtkWidget *p = item;
79   struct tree_data *pd;
80   char *comps[1024];  /* We keep pointers to the components here */
81   int i = 0, j, level,type;
82
83   /* Walk back up the tree, getting the private data */
84
85   level = GTK_TREE(item->parent)->level;
86
87   /* Pick up this item's component info */
88
89   pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(item));
90
91   comps[i++] = pd->name;
92   type = pd->type;
93
94   while (level > 0 && type != SMBC_SERVER && type != SMBC_WORKGROUP) {
95
96     /* Find the parent and extract the data etc ... */
97
98     p = GTK_WIDGET(p->parent);    
99     p = GTK_WIDGET(GTK_TREE(p)->tree_owner);
100
101     pd = (struct tree_data *)gtk_object_get_user_data(GTK_OBJECT(p));
102
103     level = GTK_TREE(item->parent)->level;
104
105     comps[i++] = pd->name;
106     type = pd->type;
107
108   }
109
110   /* 
111    * Got a list of comps now, should check that we did not hit a workgroup
112    * when we got other things as well ... Later
113    *
114    * Now, build the path
115    */
116
117   snprintf(path_string, sizeof(path_string), "smb:/");
118
119   for (j = i - 1; j >= 0; j--) {
120
121     strncat(path_string, "/", sizeof(path_string) - strlen(path_string));
122     strncat(path_string, comps[j], sizeof(path_string) - strlen(path_string));
123
124   }
125   
126   fprintf(stdout, "Path string = %s\n", path_string);
127
128   return path_string;
129
130 }
131
132 struct tree_data *make_tree_data(guint32 type, const char *name)
133 {
134   struct tree_data *p = (struct tree_data *)malloc(sizeof(struct tree_data));
135
136   if (p) {
137
138     p->type = type;
139     strncpy(p->name, name, sizeof(p->name));
140
141   }
142
143   return p;
144
145 }
146
147 /* Note that this is called every time the user clicks on an item,
148    whether it is already selected or not. */
149 static void cb_select_child (GtkWidget *root_tree, GtkWidget *child,
150                              GtkWidget *subtree)
151 {
152   gint dh, err, dirlen;
153   char dirbuf[512];
154   struct smbc_dirent *dirp;
155   struct stat st1;
156   char path[1024], path1[1024];
157
158   g_print ("select_child called for root tree %p, subtree %p, child %p\n",
159            root_tree, subtree, child);
160
161   /* Now, figure out what it is, and display it in the clist ... */
162
163   gtk_clist_clear(GTK_CLIST(clist));  /* Clear the CLIST */
164
165   /* Now, get the private data for the subtree */
166
167   strncpy(path, get_path(child), 1024);
168
169   if ((dh = smbc_opendir(path)) < 0) { /* Handle error */
170
171     g_print("cb_select_child: Could not open dir %s, %s\n", path,
172             strerror(errno));
173
174     gtk_main_quit();
175
176     return;
177
178   }
179
180   while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf,
181                               sizeof(dirbuf))) != 0) {
182
183     if (err < 0) {
184
185       g_print("cb_select_child: Could not read dir %s, %s\n", path,
186               strerror(errno));
187
188       gtk_main_quit();
189
190       return;
191
192     }
193
194     dirp = (struct smbc_dirent *)dirbuf;
195
196     while (err > 0) {
197       gchar col1[128], col2[128], col3[128], col4[128];
198       gchar *rowdata[4] = {col1, col2, col3, col4};
199
200       dirlen = dirp->dirlen;
201
202       /* Format each of the items ... */
203
204       strncpy(col1, dirp->name, 128);
205
206       col2[0] = col3[0] = col4[0] = (char)0;
207
208       switch (dirp->smbc_type) {
209
210       case SMBC_WORKGROUP:
211
212         break;
213
214       case SMBC_SERVER:
215
216         strncpy(col2, (dirp->comment?dirp->comment:""), 128);
217
218         break;
219
220       case SMBC_FILE_SHARE:
221
222         strncpy(col2, (dirp->comment?dirp->comment:""), 128);
223
224         break;
225
226       case SMBC_PRINTER_SHARE:
227
228         strncpy(col2, (dirp->comment?dirp->comment:""), 128);
229         break;
230
231       case SMBC_COMMS_SHARE:
232
233         break;
234
235       case SMBC_IPC_SHARE:
236
237         break;
238
239       case SMBC_DIR:
240       case SMBC_FILE:
241
242         /* Get stats on the file/dir and see what we have */
243
244         if ((strcmp(dirp->name, ".") != 0) &&
245             (strcmp(dirp->name, "..") != 0)) {
246
247           strncpy(path1, path, sizeof(path1));
248           strncat(path1, "/", sizeof(path) - strlen(path));
249           strncat(path1, dirp->name, sizeof(path) - strlen(path));
250
251           if (smbc_stat(path1, &st1) < 0) {
252             
253             if (errno != EBUSY) {
254               
255               g_print("cb_select_child: Could not stat file %s, %s\n", path1, 
256                       strerror(errno));
257             
258               gtk_main_quit();
259
260               return;
261
262             }
263             else {
264
265               strncpy(col2, "Device or resource busy", sizeof(col2));
266
267             }
268           }
269           else {
270             /* Now format each of the relevant things ... */
271
272             snprintf(col2, sizeof(col2), "%c%c%c%c%c%c%c%c%c(%0X)",
273                      (st1.st_mode&S_IRUSR?'r':'-'),
274                      (st1.st_mode&S_IWUSR?'w':'-'),
275                      (st1.st_mode&S_IXUSR?'x':'-'),
276                      (st1.st_mode&S_IRGRP?'r':'-'),
277                      (st1.st_mode&S_IWGRP?'w':'-'),
278                      (st1.st_mode&S_IXGRP?'x':'-'),
279                      (st1.st_mode&S_IROTH?'r':'-'),
280                      (st1.st_mode&S_IWOTH?'w':'-'),
281                      (st1.st_mode&S_IXOTH?'x':'-'),
282                      st1.st_mode); 
283             snprintf(col3, sizeof(col3), "%u", st1.st_size);
284             snprintf(col4, sizeof(col4), "%s", ctime(&st1.st_mtime));
285           }
286         }
287
288         break;
289
290       default:
291
292         break;
293       }
294
295       gtk_clist_append(GTK_CLIST(clist), rowdata);
296
297       (char *)dirp += dirlen;
298       err -= dirlen;
299
300     }
301
302   }
303
304 }
305
306 /* Note that this is never called */
307 static void cb_unselect_child( GtkWidget *root_tree,
308                                GtkWidget *child,
309                                GtkWidget *subtree )
310 {
311   g_print ("unselect_child called for root tree %p, subtree %p, child %p\n",
312            root_tree, subtree, child);
313 }
314
315 /* for all the GtkItem:: and GtkTreeItem:: signals */
316 static void cb_itemsignal( GtkWidget *item,
317                            gchar     *signame )
318 {
319   GtkWidget *real_tree, *aitem, *subtree;
320   gchar *name;
321   GtkLabel *label;
322   gint dh, err, dirlen, level;
323   char dirbuf[512];
324   struct smbc_dirent *dirp;
325   
326   label = GTK_LABEL (GTK_BIN (item)->child);
327   /* Get the text of the label */
328   gtk_label_get (label, &name);
329
330   level = GTK_TREE(item->parent)->level;
331
332   /* Get the level of the tree which the item is in */
333   g_print ("%s called for item %s->%p, level %d\n", signame, name,
334            item, GTK_TREE (item->parent)->level);
335
336   real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
337
338   if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
339     char server[128];
340
341     if ((dh = smbc_opendir(get_path(item))) < 0) { /* Handle error */
342       gchar errmsg[256];
343
344       g_print("cb_itemsignal: Could not open dir %s, %s\n", get_path(item), 
345               strerror(errno));
346
347       snprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not open dir %s, %s\n", get_path(item), strerror(errno));
348
349       error_message(errmsg);
350
351       /*      gtk_main_quit();*/
352
353       return;
354
355     }
356
357     while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
358                                 sizeof(dirbuf))) != 0) {
359
360       if (err < 0) { /* An error, report it */
361         gchar errmsg[256];
362
363         g_print("cb_itemsignal: Could not read dir smbc://, %s\n",
364                 strerror(errno));
365
366         snprintf(errmsg, sizeof(errmsg), "cb_itemsignal: Could not read dir smbc://, %s\n", strerror(errno));
367
368         error_message(errmsg);
369
370         /*      gtk_main_quit();*/
371
372         return;
373
374       }
375
376       dirp = (struct smbc_dirent *)dirbuf;
377
378       while (err > 0) {
379         struct tree_data *my_data;
380
381         dirlen = dirp->dirlen;
382
383         my_data = make_tree_data(dirp->smbc_type, dirp->name);
384
385         if (!my_data) {
386
387           g_print("Could not allocate space for tree_data: %s\n",
388                   dirp->name);
389
390           gtk_main_quit();
391           return;
392
393         }
394
395         aitem = gtk_tree_item_new_with_label(dirp->name);
396
397         /* Connect all GtkItem:: and GtkTreeItem:: signals */
398         gtk_signal_connect (GTK_OBJECT(aitem), "select",
399                             GTK_SIGNAL_FUNC(cb_itemsignal), "select");
400         gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
401                             GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
402         gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
403                             GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
404         gtk_signal_connect (GTK_OBJECT(aitem), "expand",
405                             GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
406         gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
407                             GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
408         /* Add it to the parent tree */
409         gtk_tree_append (GTK_TREE(real_tree), aitem);
410
411         gtk_widget_show (aitem);
412
413         gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
414
415         fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
416
417         if (dirp->smbc_type != SMBC_FILE &&
418             dirp->smbc_type != SMBC_IPC_SHARE &&
419             (strcmp(dirp->name, ".") != 0) && 
420             (strcmp(dirp->name, "..") !=0)){
421           
422           subtree = gtk_tree_new();
423           gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
424
425           gtk_signal_connect(GTK_OBJECT(subtree), "select_child",
426                              GTK_SIGNAL_FUNC(cb_select_child), real_tree);
427           gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child",
428                              GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
429
430         }
431
432         (char *)dirp += dirlen;
433         err -= dirlen;
434
435       }
436
437     }
438
439     smbc_closedir(dh);   
440
441   }
442   else if (strncmp(signame, "collapse", 8) == 0) {
443     GtkWidget *subtree = gtk_tree_new();
444
445     gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children);
446
447     gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
448
449     gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
450                         GTK_SIGNAL_FUNC(cb_select_child), real_tree);
451     gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
452                         GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
453
454   }
455
456 }
457
458 static void cb_selection_changed( GtkWidget *tree )
459 {
460   GList *i;
461   
462   g_print ("selection_change called for tree %p\n", tree);
463   g_print ("selected objects are:\n");
464
465   i = GTK_TREE_SELECTION(tree);
466   while (i){
467     gchar *name;
468     GtkLabel *label;
469     GtkWidget *item;
470
471     /* Get a GtkWidget pointer from the list node */
472     item = GTK_WIDGET (i->data);
473     label = GTK_LABEL (GTK_BIN (item)->child);
474     gtk_label_get (label, &name);
475     g_print ("\t%s on level %d\n", name, GTK_TREE
476              (item->parent)->level);
477     i = i->next;
478   }
479 }
480
481 /*
482  * Expand or collapse the whole network ...
483  */
484 static void cb_wholenet(GtkWidget *item, gchar *signame)
485 {
486   GtkWidget *real_tree, *aitem, *subtree;
487   gchar *name;
488   GtkLabel *label;
489   gint dh, err, dirlen;
490   char dirbuf[512];
491   struct smbc_dirent *dirp;
492   
493   label = GTK_LABEL (GTK_BIN (item)->child);
494   gtk_label_get (label, &name);
495   g_print ("%s called for item %s->%p, level %d\n", signame, name,
496            item, GTK_TREE (item->parent)->level);
497
498   real_tree = GTK_TREE_ITEM_SUBTREE(item);  /* Get the subtree */
499
500   if (strncmp(signame, "expand", 6) == 0) { /* Expand called */
501
502     if ((dh = smbc_opendir("smb://")) < 0) { /* Handle error */
503
504       g_print("cb_wholenet: Could not open dir smbc://, %s\n",
505               strerror(errno));
506
507       gtk_main_quit();
508
509       return;
510
511     }
512
513     while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
514                                 sizeof(dirbuf))) != 0) {
515
516       if (err < 0) { /* An error, report it */
517
518         g_print("cb_wholenet: Could not read dir smbc://, %s\n",
519                 strerror(errno));
520
521         gtk_main_quit();
522
523         return;
524
525       }
526
527       dirp = (struct smbc_dirent *)dirbuf;
528
529       while (err > 0) {
530         struct tree_data *my_data;
531
532         dirlen = dirp->dirlen;
533
534         my_data = make_tree_data(dirp->smbc_type, dirp->name);
535
536         aitem = gtk_tree_item_new_with_label(dirp->name);
537
538         /* Connect all GtkItem:: and GtkTreeItem:: signals */
539         gtk_signal_connect (GTK_OBJECT(aitem), "select",
540                             GTK_SIGNAL_FUNC(cb_itemsignal), "select");
541         gtk_signal_connect (GTK_OBJECT(aitem), "deselect",
542                             GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
543         gtk_signal_connect (GTK_OBJECT(aitem), "toggle",
544                             GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
545         gtk_signal_connect (GTK_OBJECT(aitem), "expand",
546                             GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
547         gtk_signal_connect (GTK_OBJECT(aitem), "collapse",
548                             GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
549
550         gtk_tree_append (GTK_TREE(real_tree), aitem);
551         /* Show it - this can be done at any time */
552         gtk_widget_show (aitem);
553
554         gtk_object_set_user_data(GTK_OBJECT(aitem), (gpointer)my_data);
555
556         fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
557
558         subtree = gtk_tree_new();
559
560         gtk_tree_item_set_subtree(GTK_TREE_ITEM(aitem), subtree);
561
562         gtk_signal_connect(GTK_OBJECT(subtree), "select_child",
563                            GTK_SIGNAL_FUNC(cb_select_child), real_tree);
564         gtk_signal_connect(GTK_OBJECT(subtree), "unselect_child",
565                            GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
566
567         (char *)dirp += dirlen;
568         err -= dirlen;
569
570       }
571
572     }
573
574     smbc_closedir(dh);   
575
576   }
577   else { /* Must be collapse ... FIXME ... */
578     GtkWidget *subtree = gtk_tree_new();
579
580     gtk_tree_remove_items(GTK_TREE(real_tree), GTK_TREE(real_tree)->children);
581
582     gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
583
584     gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
585                         GTK_SIGNAL_FUNC(cb_select_child), real_tree);
586     gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
587                         GTK_SIGNAL_FUNC(cb_unselect_child), real_tree);
588
589
590   }
591
592 }
593
594 /* Should put up a dialog box to ask the user for username and password */
595
596 static void 
597 auth_fn(const char *server, const char *share,
598         char *workgroup, int wgmaxlen, char *username, int unmaxlen,
599         char *password, int pwmaxlen)
600 {
601
602    strncpy(username, "test", unmaxlen);
603    strncpy(password, "test", pwmaxlen);
604
605 }
606
607 static char *col_titles[] = {
608   "Name", "Attributes", "Size", "Modification Date",
609 };
610
611 int main( int   argc,
612           char *argv[] )
613 {
614   GtkWidget *window, *scrolled_win, *scrolled_win2, *tree;
615   GtkWidget *subtree, *item, *main_hbox, *r_pane, *l_pane;
616   gint err, dh;
617   gint i;
618   char dirbuf[512];
619   struct smbc_dirent *dirp;
620
621   gtk_init (&argc, &argv);
622
623   /* Init the smbclient library */
624
625   err = smbc_init(auth_fn, 10);
626
627   /* Print an error response ... */
628
629   if (err < 0) {
630
631     fprintf(stderr, "smbc_init returned %s (%i)\nDo you have a ~/.smb/smb.conf file?\n", strerror(errno), errno);
632     exit(1);
633
634   }
635
636   /* a generic toplevel window */
637   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
638   gtk_widget_set_name(window, "main browser window");
639   gtk_signal_connect (GTK_OBJECT(window), "delete_event",
640                       GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
641   gtk_window_set_title(GTK_WINDOW(window), "The Linux Windows Network Browser");
642   gtk_widget_set_usize(GTK_WIDGET(window), 750, -1);
643   gtk_container_set_border_width (GTK_CONTAINER(window), 5);
644
645   gtk_widget_show (window);
646
647   /* A container for the two panes ... */
648
649   main_hbox = gtk_hbox_new(FALSE, 1);
650   gtk_container_border_width(GTK_CONTAINER(main_hbox), 1);
651   gtk_container_add(GTK_CONTAINER(window), main_hbox);
652
653   gtk_widget_show(main_hbox);
654
655   l_pane = gtk_hpaned_new();
656   gtk_paned_gutter_size(GTK_PANED(l_pane), (GTK_PANED(l_pane))->handle_size);
657   r_pane = gtk_hpaned_new();
658   gtk_paned_gutter_size(GTK_PANED(r_pane), (GTK_PANED(r_pane))->handle_size);
659   gtk_container_add(GTK_CONTAINER(main_hbox), l_pane);
660   gtk_widget_show(l_pane);
661
662   /* A generic scrolled window */
663   scrolled_win = gtk_scrolled_window_new (NULL, NULL);
664   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
665                                   GTK_POLICY_AUTOMATIC,
666                                   GTK_POLICY_AUTOMATIC);
667   gtk_widget_set_usize (scrolled_win, 150, 200);
668   gtk_container_add (GTK_CONTAINER(l_pane), scrolled_win);
669   gtk_widget_show (scrolled_win);
670
671   /* Another generic scrolled window */
672   scrolled_win2 = gtk_scrolled_window_new (NULL, NULL);
673   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win2),
674                                   GTK_POLICY_AUTOMATIC,
675                                   GTK_POLICY_AUTOMATIC);
676   gtk_widget_set_usize (scrolled_win2, 150, 200);
677   gtk_paned_add2 (GTK_PANED(l_pane), scrolled_win2);
678   gtk_widget_show (scrolled_win2);
679   
680   /* Create the root tree */
681   tree = gtk_tree_new();
682   g_print ("root tree is %p\n", tree);
683   /* connect all GtkTree:: signals */
684   gtk_signal_connect (GTK_OBJECT(tree), "select_child",
685                       GTK_SIGNAL_FUNC(cb_select_child), tree);
686   gtk_signal_connect (GTK_OBJECT(tree), "unselect_child",
687                       GTK_SIGNAL_FUNC(cb_unselect_child), tree);
688   gtk_signal_connect (GTK_OBJECT(tree), "selection_changed",
689                       GTK_SIGNAL_FUNC(cb_selection_changed), tree);
690   /* Add it to the scrolled window */
691   gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(scrolled_win),
692                                          tree);
693   /* Set the selection mode */
694   gtk_tree_set_selection_mode (GTK_TREE(tree),
695                                GTK_SELECTION_MULTIPLE);
696   /* Show it */
697   gtk_widget_show (tree);
698
699   /* Now, create a clist and attach it to the second pane */
700
701   clist = gtk_clist_new_with_titles(4, col_titles);
702
703   gtk_container_add (GTK_CONTAINER(scrolled_win2), clist);
704
705   gtk_widget_show(clist);
706
707   /* Now, build the top level display ... */
708
709   if ((dh = smbc_opendir("smb:///")) < 0) {
710
711     fprintf(stderr, "Could not list default workgroup: smb:///: %s\n",
712             strerror(errno));
713
714     exit(1);
715
716   }
717
718   /* Create a tree item for Whole Network */
719
720   item = gtk_tree_item_new_with_label ("Whole Network");
721   /* Connect all GtkItem:: and GtkTreeItem:: signals */
722   gtk_signal_connect (GTK_OBJECT(item), "select",
723                       GTK_SIGNAL_FUNC(cb_itemsignal), "select");
724   gtk_signal_connect (GTK_OBJECT(item), "deselect",
725                       GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
726   gtk_signal_connect (GTK_OBJECT(item), "toggle",
727                       GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
728   gtk_signal_connect (GTK_OBJECT(item), "expand",
729                       GTK_SIGNAL_FUNC(cb_wholenet), "expand");
730   gtk_signal_connect (GTK_OBJECT(item), "collapse",
731                       GTK_SIGNAL_FUNC(cb_wholenet), "collapse");
732   /* Add it to the parent tree */
733   gtk_tree_append (GTK_TREE(tree), item);
734   /* Show it - this can be done at any time */
735   gtk_widget_show (item);
736
737   subtree = gtk_tree_new();  /* A subtree for Whole Network */
738
739   gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
740
741   gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
742                       GTK_SIGNAL_FUNC(cb_select_child), tree);
743   gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
744                       GTK_SIGNAL_FUNC(cb_unselect_child), tree);
745
746   /* Now, get the items in smb:/// and add them to the tree */
747
748   dirp = (struct smbc_dirent *)dirbuf;
749
750   while ((err = smbc_getdents(dh, (struct smbc_dirent *)dirbuf, 
751                               sizeof(dirbuf))) != 0) {
752
753     if (err < 0) { /* Handle the error */
754
755       fprintf(stderr, "Could not read directory for smbc:///: %s\n",
756               strerror(errno));
757
758       exit(1);
759
760     }
761
762     fprintf(stdout, "Dir len: %u\n", err);
763
764     while (err > 0) { /* Extract each entry and make a sub-tree */
765       struct tree_data *my_data;
766       int dirlen = dirp->dirlen;
767
768       my_data = make_tree_data(dirp->smbc_type, dirp->name);
769
770       item = gtk_tree_item_new_with_label(dirp->name);
771       /* Connect all GtkItem:: and GtkTreeItem:: signals */
772       gtk_signal_connect (GTK_OBJECT(item), "select",
773                           GTK_SIGNAL_FUNC(cb_itemsignal), "select");
774       gtk_signal_connect (GTK_OBJECT(item), "deselect",
775                           GTK_SIGNAL_FUNC(cb_itemsignal), "deselect");
776       gtk_signal_connect (GTK_OBJECT(item), "toggle",
777                           GTK_SIGNAL_FUNC(cb_itemsignal), "toggle");
778       gtk_signal_connect (GTK_OBJECT(item), "expand",
779                           GTK_SIGNAL_FUNC(cb_itemsignal), "expand");
780       gtk_signal_connect (GTK_OBJECT(item), "collapse",
781                           GTK_SIGNAL_FUNC(cb_itemsignal), "collapse");
782       /* Add it to the parent tree */
783       gtk_tree_append (GTK_TREE(tree), item);
784       /* Show it - this can be done at any time */
785       gtk_widget_show (item);
786
787       gtk_object_set_user_data(GTK_OBJECT(item), (gpointer)my_data);
788
789       fprintf(stdout, "Added: %s, len: %u\n", dirp->name, dirlen);
790
791       subtree = gtk_tree_new();
792
793       gtk_tree_item_set_subtree(GTK_TREE_ITEM(item), subtree);
794
795       gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
796                           GTK_SIGNAL_FUNC(cb_select_child), tree);
797       gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
798                           GTK_SIGNAL_FUNC(cb_unselect_child), tree);
799
800       (char *)dirp += dirlen;
801       err -= dirlen;
802
803     }
804
805   }
806
807   smbc_closedir(dh); /* FIXME, check for error :-) */
808
809   /* Show the window and loop endlessly */
810   gtk_main();
811   return 0;
812 }
813 /* example-end */