webcit/roomlist.c

   1 /*
   2  * room listings and filters.
   3  */
   4
   5 #include "webcit.h"
   6 #include "webserver.h"
   7
   8
   9 HashList *GetWhoKnowsHash(StrBuf *Target, WCTemplputParams *TP)
  10 {
  11         StrBuf *Line;
  12         StrBuf *Token;
  13         long State;
  14         HashList *Whok = NULL;
  15         int Done = 0;
  16         int n = 0;
  17
  18         serv_puts("WHOK");
  19         Line = NewStrBuf();
  20         StrBuf_ServGetln(Line);
  21         if (GetServerStatus(Line, &State) == 1)
  22         {
  23                 Whok = NewHash(1, Flathash);
  24                 while(!Done && (StrBuf_ServGetln(Line) >= 0) )
  25                         if ( (StrLength(Line)==3) &&
  26                              !strcmp(ChrPtr(Line), "000"))
  27                         {
  28                                 Done = 1;
  29                         }
  30                         else
  31                         {
  32
  33                                 const char *Pos = NULL;
  34                                 Token = NewStrBufPlain (NULL, StrLength(Line));
  35                                 StrBufExtract_NextToken(Token, Line, &Pos, '|');
  36
  37                                 Put(Whok,
  38                                     IKEY(n),
  39                                     Token,
  40                                     HFreeStrBuf);
  41                                 n++;
  42                         }
  43         }
  44         else if (State == 550)
  45                 AppendImportantMessage(_("Higher access is required to access this function."), -1);
  46
  47
  48         FreeStrBuf(&Line);
  49         return Whok;
  50 }
  51
  52
  53 void DeleteFloor(void *vFloor)
  54 {
  55         Floor *pFloor;
  56         pFloor = (Floor*) vFloor;
  57         FreeStrBuf(&pFloor->Name);
  58         free(pFloor);
  59 }
  60
  61 int SortFloorsByNameOrder(const void *vfloor1, const void *vfloor2)
  62 {
  63         Floor *f1 = (Floor*) GetSearchPayload(vfloor1);
  64         Floor *f2 = (Floor*) GetSearchPayload(vfloor2);
  65
  66         /* prefer My floor over alpabetical sort */
  67         if (f1->ID == VIRTUAL_MY_FLOOR)
  68                 return 1;
  69         if (f2->ID == VIRTUAL_MY_FLOOR)
  70                 return -1;
  71
  72         return strcmp(ChrPtr(f1->Name), ChrPtr(f2->Name));
  73 }
  74
  75 HashList *GetFloorListHash(StrBuf *Target, WCTemplputParams *TP)
  76 {
  77         int Done = 0;
  78         const char *Err;
  79         StrBuf *Buf;
  80         HashList *floors;
  81         HashList *floorsbyname;
  82         HashPos *it;
  83         Floor *pFloor;
  84         void *vFloor;
  85         const char *Pos;
  86         int i;
  87         wcsession *WCC = WC;
  88         const char *HashKey;
  89         long HKLen;
  90
  91
  92         if (WCC->Floors != NULL)
  93                 return WCC->Floors;
  94         WCC->Floors = floors = NewHash(1, Flathash);
  95         WCC->FloorsByName = floorsbyname = NewHash(1, NULL);
  96         Buf = NewStrBuf();
  97
  98         pFloor = (Floor*) malloc(sizeof(Floor));
  99         pFloor->ID = VIRTUAL_MY_FLOOR;
 100         pFloor->Name = NewStrBufPlain(_("My Folders"), -1);
 101         pFloor->NRooms = 0;
 102
 103         Put(floors, IKEY(pFloor->ID), pFloor, DeleteFloor);
 104         Put(floorsbyname, SKEY(pFloor->Name), pFloor, reference_free_handler);
 105
 106         serv_puts("LFLR"); /* get floors */
 107         StrBufTCP_read_line(Buf, &WC->serv_sock, 0, &Err); /* '100', we hope */
 108         if (GetServerStatus(Buf, NULL) == 1)
 109         {
 110                 while(!Done && StrBuf_ServGetln(Buf) >= 0)
 111                         if ( (StrLength(Buf)==3) &&
 112                              !strcmp(ChrPtr(Buf), "000"))
 113                         {
 114                                 Done = 1;
 115                         }
 116                         else
 117                         {
 118
 119                                 Pos = NULL;
 120
 121                                 pFloor = (Floor*) malloc(sizeof(Floor));
 122                                 pFloor->ID = StrBufExtractNext_int(Buf, &Pos, '|');
 123                                 pFloor->Name = NewStrBufPlain(NULL, StrLength(Buf));
 124                                 StrBufExtract_NextToken(pFloor->Name, Buf, &Pos, '|');
 125                                 pFloor->NRooms = StrBufExtractNext_long(Buf, &Pos, '|');
 126
 127                                 Put(floors, IKEY(pFloor->ID), pFloor, DeleteFloor);
 128                                 Put(floorsbyname, SKEY(pFloor->Name), pFloor, reference_free_handler);
 129                         }
 130         }
 131         FreeStrBuf(&Buf);
 132
 133         /* now lets pre-sort them alphabeticaly. */
 134         i = 1;
 135         SortByPayload(floors, SortFloorsByNameOrder);
 136         it = GetNewHashPos(floors, 0);
 137         while ( GetNextHashPos(floors, it, &HKLen, &HashKey, &vFloor))
 138                 ((Floor*) vFloor)->AlphaN = i++;
 139         DeleteHashPos(&it);
 140         SortByHashKeyStr(floors);
 141
 142         return floors;
 143 }
 144
 145 HashList *GetZappedRoomListHash(StrBuf *Target, WCTemplputParams *TP)
 146 {
 147         wcsession *WCC = WC;
 148
 149         if (WCC->Floors == NULL)
 150                 GetFloorListHash(Target, TP);
 151         serv_puts("LZRM -1");
 152         return GetRoomListHash(Target, TP);
 153 }
 154 HashList *GetRoomListHashLKRA(StrBuf *Target, WCTemplputParams *TP)
 155 {
 156         wcsession *WCC = WC;
 157
 158         if (WCC->Floors == NULL)
 159                 GetFloorListHash(Target, TP);
 160         if (WCC->Rooms == NULL)
 161         {
 162                 serv_puts("LKRA");
 163                 WCC->Rooms =  GetRoomListHash(Target, TP);
 164         }
 165         return WCC->Rooms;
 166 }
 167
 168 HashList *GetRoomListHashLPRM(StrBuf *Target, WCTemplputParams *TP)
 169 {
 170         serv_puts("LPRM");
 171         return GetRoomListHash(Target, TP);
 172 }
 173
 174
 175 void FlushIgnetCfgs(folder *room)
 176 {
 177         int i;
 178         if (room->IgnetCfgs[maxRoomNetCfg] == (HashList*) StrBufNOTNULL)
 179         {
 180                 for (i = ignet_push_share; i < maxRoomNetCfg; i++)
 181                         DeleteHash(&room->IgnetCfgs[i]);
 182         }
 183         memset(&room->IgnetCfgs, 0, sizeof(HashList *) * (maxRoomNetCfg + 1));
 184
 185 }
 186
 187 void FlushFolder(folder *room)
 188 {
 189         int i;
 190
 191         FreeStrBuf(&room->XAPass);
 192         FreeStrBuf(&room->Directory);
 193         FreeStrBuf(&room->RoomAide);
 194         FreeStrBuf(&room->XInfoText);
 195         room->XHaveInfoTextLoaded = 0;
 196
 197         FreeStrBuf(&room->name);
 198
 199         FlushIgnetCfgs(room);
 200
 201         if (room->RoomNameParts != NULL)
 202         {
 203                 for (i=0; i < room->nRoomNameParts; i++)
 204                         FreeStrBuf(&room->RoomNameParts[i]);
 205                 free(room->RoomNameParts);
 206         }
 207         memset(room, 0, sizeof(folder));
 208 }
 209
 210 void vDeleteFolder(void *vFolder)
 211 {
 212         folder *room;
 213
 214         room = (folder*) vFolder;
 215         FlushFolder(room);
 216
 217         free(room);
 218 }
 219
 220
 221 HashList *GetRoomListHash(StrBuf *Target, WCTemplputParams *TP)
 222 {
 223         int Done = 0;
 224         HashList *rooms;
 225         folder *room;
 226         StrBuf *Buf;
 227         const char *Pos;
 228         void *vFloor;
 229         wcsession *WCC = WC;
 230         CompareFunc SortIt;
 231         WCTemplputParams SubTP;
 232
 233         Buf = NewStrBuf();
 234         rooms = NewHash(1, NULL);
 235         StrBuf_ServGetln(Buf);
 236         if (GetServerStatus(Buf, NULL) == 1)
 237         {
 238                 while(!Done && (StrBuf_ServGetln(Buf) >= 0))
 239                         if ( (StrLength(Buf)==3) &&
 240                              !strcmp(ChrPtr(Buf), "000"))
 241                         {
 242                                 Done = 1;
 243                         }
 244                         else
 245                         {
 246                                 Pos = NULL;
 247                                 room = (folder*) malloc (sizeof(folder));
 248                                 memset(room, 0, sizeof(folder));
 249
 250                                 /* Load the base data from the server reply */
 251                                 room->name = NewStrBufPlain(NULL, StrLength(Buf));
 252                                 StrBufExtract_NextToken(room->name, Buf, &Pos, '|');
 253
 254                                 room->QRFlags = StrBufExtractNext_long(Buf, &Pos, '|');
 255                                 room->floorid = StrBufExtractNext_int(Buf, &Pos, '|');
 256                                 room->Order = StrBufExtractNext_long(Buf, &Pos, '|');
 257                                 room->QRFlags2 = StrBufExtractNext_long(Buf, &Pos, '|');
 258
 259                                 room->RAFlags = StrBufExtractNext_long(Buf, &Pos, '|');
 260
 261 /*
 262   ACWHUT?
 263   room->ACL = NewStrBufPlain(NULL, StrLength(Buf));
 264   StrBufExtract_NextToken(room->ACL, Buf, &Pos, '|');
 265 */
 266
 267                                 room->view = StrBufExtractNext_long(Buf, &Pos, '|');
 268                                 room->defview = StrBufExtractNext_long(Buf, &Pos, '|');
 269                                 room->lastchange = StrBufExtractNext_long(Buf, &Pos, '|');
 270
 271                                 /* Evaluate the Server sent data for later use */
 272                                 /* find out, whether we are in a sub-room */
 273                                 room->nRoomNameParts = StrBufNum_tokens(room->name, '\\');
 274                                 if (room->nRoomNameParts > 1)
 275                                 {
 276                                         int i;
 277
 278                                         Pos = NULL;
 279                                         room->RoomNameParts = malloc(sizeof(StrBuf*) * (room->nRoomNameParts + 1));
 280                                         memset(room->RoomNameParts, 0, sizeof(StrBuf*) * (room->nRoomNameParts + 1));
 281                                         for (i=0; i < room->nRoomNameParts; i++)
 282                                         {
 283                                                 room->RoomNameParts[i] = NewStrBuf();
 284                                                 StrBufExtract_NextToken(room->RoomNameParts[i],
 285                                                                         room->name, &Pos, '\\');
 286                                         }
 287                                 }
 288
 289                                 /* Private mailboxes on the main floor get remapped to the personal folder */
 290                                 if ((room->QRFlags & QR_MAILBOX) &&
 291                                     (room->floorid == 0))
 292                                 {
 293                                         room->floorid = VIRTUAL_MY_FLOOR;
 294                                         if ((room->nRoomNameParts == 1) &&
 295                                             (StrLength(room->name) == 4) &&
 296                                             (strcmp(ChrPtr(room->name), "Mail") == 0))
 297                                         {
 298                                                 room->is_inbox = 1;
 299                                         }
 300
 301                                 }
 302                                 /* get a pointer to the floor we're on: */
 303                                 GetHash(WCC->Floors, IKEY(room->floorid), &vFloor);
 304                                 room->Floor = (const Floor*) vFloor;
 305
 306
 307
 308                                 /* now we know everything, remember it... */
 309                                 Put(rooms, SKEY(room->name), room, vDeleteFolder);
 310                         }
 311         }
 312
 313         SubTP.Filter.ContextType = CTX_ROOMS;
 314         SortIt = RetrieveSort(&SubTP, NULL, 0, HKEY("fileunsorted"), 0);
 315         if (SortIt != NULL)
 316                 SortByPayload(rooms, SortIt);
 317         else
 318                 SortByPayload(rooms, SortRoomsByListOrder);
 319         FreeStrBuf(&Buf);
 320         return rooms;
 321 }
 322
 323 HashList *GetThisRoomMAlias(StrBuf *Target, WCTemplputParams *TP)
 324 {
 325         wcsession *WCC = WC;
 326         StrBuf *Line;
 327         StrBuf *Token;
 328         HashList *Aliases = NULL;
 329         const char *pComma;
 330         long aliaslen;
 331         long locallen;
 332         long State;
 333
 334         serv_puts("GNET "FILE_MAILALIAS);
 335         Line = NewStrBuf();
 336         StrBuf_ServGetln(Line);
 337         if (GetServerStatus(Line, &State) == 1)
 338         {
 339                 int Done = 0;
 340                 int n = 0;
 341
 342                 Aliases = NewHash(1, NULL);
 343                 while(!Done && (StrBuf_ServGetln(Line) >= 0))
 344                         if ( (StrLength(Line)==3) &&
 345                              !strcmp(ChrPtr(Line), "000"))
 346                         {
 347                                 Done = 1;
 348                         }
 349                         else
 350                         {
 351                                 pComma = strchr(ChrPtr(Line), ',');
 352                                 if (pComma == NULL)
 353                                         continue;
 354                                 aliaslen = pComma - ChrPtr(Line);
 355                                 locallen = StrLength(Line) - 1 - aliaslen;
 356                                 if (locallen - 5 != StrLength(WCC->CurRoom.name))
 357                                         continue;
 358                                 if (strncmp(pComma + 1, "room_", 5) != 0)
 359                                         continue;
 360
 361                                 if (strcasecmp(pComma + 6, ChrPtr(WCC->CurRoom.name)) != 0)
 362                                         continue;
 363                                 Token = NewStrBufPlain(ChrPtr(Line), aliaslen);
 364                                 Put(Aliases,
 365                                     IKEY(n),
 366                                     Token,
 367                                     HFreeStrBuf);
 368                                 n++; /* #0 is the type... */
 369                         }
 370         }
 371         else if (State == 550)
 372                 AppendImportantMessage(_("Higher access is required to access this function."), -1);
 373
 374         FreeStrBuf(&Line);
 375
 376         return Aliases;
 377 }
 378
 379 HashList *GetNetConfigHash(StrBuf *Target, WCTemplputParams *TP)
 380 {
 381         wcsession *WCC = WC;
 382         StrBuf *Line;
 383         StrBuf *Token;
 384         StrBuf *Content;
 385         long WantThisOne;
 386         long PutTo;
 387         long State;
 388
 389         WantThisOne = GetTemplateTokenNumber(Target, TP, 5, -1);
 390         if ((WantThisOne < 0) || (WantThisOne > maxRoomNetCfg))
 391                 return NULL;
 392         if (WCC->CurRoom.IgnetCfgs[maxRoomNetCfg] == (HashList*) StrBufNOTNULL)
 393                 return WCC->CurRoom.IgnetCfgs[WantThisOne];
 394
 395         WCC->CurRoom.IgnetCfgs[maxRoomNetCfg] = (HashList*) StrBufNOTNULL;
 396         serv_puts("GNET");
 397         Line = NewStrBuf();
 398         Token = NewStrBuf();
 399         StrBuf_ServGetln(Line);
 400         if (GetServerStatus(Line, &State) == 1)
 401         {
 402                 const char *Pos = NULL;
 403                 int Done = 0;
 404
 405                 while(!Done && (StrBuf_ServGetln(Line) >= 0))
 406                         if ( (StrLength(Line)==3) &&
 407                              !strcmp(ChrPtr(Line), "000"))
 408                         {
 409                                 Done = 1;
 410                         }
 411                         else
 412                         {
 413                                 StrBufExtract_NextToken(Token, Line, &Pos, '|');
 414                                 PutTo = GetTokenDefine(SKEY(Token), -1);
 415                                 if ((PutTo >= 0) &&
 416                                     (PutTo < maxRoomNetCfg) &&
 417                                     (Pos != StrBufNOTNULL))
 418                                 {
 419                                         int n;
 420                                         HashList *SubH;
 421
 422                                         if (WCC->CurRoom.IgnetCfgs[PutTo] == NULL)
 423                                         {
 424                                                 n = 0;
 425                                                 WCC->CurRoom.IgnetCfgs[PutTo] = NewHash(1, NULL);
 426                                         }
 427                                         else
 428                                         {
 429                                                 n = GetCount(WCC->CurRoom.IgnetCfgs[PutTo]);
 430                                         }
 431                                         SubH = NewHash(1, NULL);
 432                                         Put(WCC->CurRoom.IgnetCfgs[PutTo],
 433                                             IKEY(n),
 434                                             SubH,
 435                                             HDeleteHash);
 436                                         n = 1; /* #0 is the type... */
 437                                         while (Pos != StrBufNOTNULL) {
 438                                                 Content = NewStrBuf();
 439                                                 StrBufExtract_NextToken(Content, Line, &Pos, '|');
 440                                                 Put(SubH,
 441                                                     IKEY(n),
 442                                                     Content,
 443                                                     HFreeStrBuf);
 444                                                 n++;
 445                                         }
 446                                 }
 447                                 Pos = NULL;
 448                         }
 449         }
 450         else if (State == 550)
 451                 AppendImportantMessage(_("Higher access is required to access this function."), -1);
 452
 453         FreeStrBuf(&Line);
 454         FreeStrBuf(&Token);
 455
 456         return WCC->CurRoom.IgnetCfgs[WantThisOne];
 457 }
 458
 459 /** Unused function that orders rooms by the listorder flag */
 460 int SortRoomsByListOrder(const void *room1, const void *room2)
 461 {
 462         folder *r1 = (folder*) GetSearchPayload(room1);
 463         folder *r2 = (folder*) GetSearchPayload(room2);
 464
 465         if (r1->Order == r2->Order) return 0;
 466         if (r1->Order > r2->Order) return 1;
 467         return -1;
 468 }
 469
 470 int CompareRoomListByFloorRoomPrivFirst(const void *room1, const void *room2)
 471 {
 472         folder *r1 = (folder*) GetSearchPayload(room1);
 473         folder *r2 = (folder*) GetSearchPayload(room2);
 474
 475         if ((r1->Floor == NULL)  ||
 476             (r2->Floor == NULL))
 477                 return 0;
 478
 479         /**
 480          * are we on the same floor? else sort by floor.
 481          */
 482         if (r1->Floor != r2->Floor)
 483         {
 484                 /**
 485                  * the private rooms are first in any case.
 486                  */
 487                 if (r1->Floor->ID == VIRTUAL_MY_FLOOR)
 488                         return -1;
 489                 if (r2->Floor->ID == VIRTUAL_MY_FLOOR)
 490                         return 1;
 491                 /**
 492                  * else decide alpaheticaly by floorname
 493                  */
 494                 return (r1->Floor->AlphaN > r2->Floor->AlphaN)? 1 : -1;
 495         }
 496
 497         /**
 498          * if we have different levels of subdirectories,
 499          * we want the toplevel to be first, regardless of sort
 500          * sequence.
 501          */
 502         if (((r1->nRoomNameParts > 1) ||
 503             (r2->nRoomNameParts > 1)    )&&
 504             (r1->nRoomNameParts != r2->nRoomNameParts))
 505         {
 506                 int i, ret;
 507                 int nparts = (r1->nRoomNameParts > r2->nRoomNameParts)?
 508                         r2->nRoomNameParts : r1->nRoomNameParts;
 509
 510                 for (i=0; i < nparts; i++)
 511                 {
 512                         ret = strcmp (ChrPtr(r1->name),
 513                                       ChrPtr(r2->name));
 514                         /**
 515                          * Deltas in common parts? exit here.
 516                          */
 517                         if (ret != 0)
 518                                 return ret;
 519                 }
 520
 521                 /**
 522                  * who's a subdirectory of whom?
 523                  */
 524                 if (r1->nRoomNameParts > r2->nRoomNameParts)
 525                         return 1;
 526                 else
 527                         return -1;
 528
 529         }
 530
 531         /**
 532          * else just sort alphabeticaly.
 533          */
 534         return strcmp (ChrPtr(r1->name),
 535                        ChrPtr(r2->name));
 536 }
 537
 538 int CompareRoomListByFloorRoomPrivFirstRev(const void *room1, const void *room2)
 539 {
 540         folder *r1 = (folder*) GetSearchPayload(room1);
 541         folder *r2 = (folder*) GetSearchPayload(room2);
 542
 543         if ((r1->Floor == NULL)  ||
 544             (r2->Floor == NULL))
 545                 return 0;
 546
 547         /**
 548          * are we on the same floor? else sort by floor.
 549          */
 550         if (r2->Floor != r1->Floor)
 551         {
 552                 /**
 553                  * the private rooms are first in any case.
 554                  */
 555                 if (r1->Floor->ID == VIRTUAL_MY_FLOOR)
 556                         return -1;
 557                 if (r2->Floor->ID == VIRTUAL_MY_FLOOR)
 558                         return 1;
 559                 /**
 560                  * else decide alpaheticaly by floorname
 561                  */
 562
 563                 return (r1->Floor->AlphaN < r2->Floor->AlphaN)? 1 : -1;
 564         }
 565
 566         /**
 567          * if we have different levels of subdirectories,
 568          * we want the toplevel to be first, regardless of sort
 569          * sequence.
 570          */
 571         if (((r1->nRoomNameParts > 1) ||
 572             (r2->nRoomNameParts > 1)    )&&
 573             (r1->nRoomNameParts != r2->nRoomNameParts))
 574         {
 575                 int i, ret;
 576                 int nparts = (r1->nRoomNameParts > r2->nRoomNameParts)?
 577                         r2->nRoomNameParts : r1->nRoomNameParts;
 578
 579                 for (i=0; i < nparts; i++)
 580                 {
 581                         /**
 582                          * special cases if one room is top-level...
 583                          */
 584                         if (r2->nRoomNameParts == 1)
 585                                 ret = strcmp (ChrPtr(r2->name),
 586                                               ChrPtr(r1->RoomNameParts[i]));
 587                         else if (r1->nRoomNameParts == 1)
 588                                 ret = strcmp (ChrPtr(r2->RoomNameParts[i]),
 589                                               ChrPtr(r1->name));
 590                         else
 591                                 ret = strcmp (ChrPtr(r2->RoomNameParts[i]),
 592                                               ChrPtr(r1->RoomNameParts[i]));
 593                         /**
 594                          * Deltas in common parts? exit here.
 595                          */
 596                         if (ret != 0)
 597                                 return ret;
 598                 }
 599
 600                 /**
 601                  * who's a subdirectory of whom?
 602                  */
 603                 if (r1->nRoomNameParts > r2->nRoomNameParts)
 604                         return 1;
 605                 else
 606                         return -1;
 607         }
 608
 609         return strcmp (ChrPtr(r2->name),
 610                        ChrPtr(r1->name));
 611 }
 612
 613 int GroupchangeRoomListByFloorRoomPrivFirst(const void *room1, const void *room2)
 614 {
 615         folder *r1 = (folder*) room1;
 616         folder *r2 = (folder*) room2;
 617
 618
 619         if ((r1->Floor == NULL)  ||
 620             (r2->Floor == NULL))
 621                 return 0;
 622
 623         if (r1->Floor == r2->Floor)
 624                 return 0;
 625         else
 626         {
 627                 wcsession *WCC = WC;
 628                 static int columns = 3;
 629                 int boxes_per_column = 0;
 630                 int nf;
 631
 632                 nf = GetCount(WCC->Floors);
 633                 while (nf % columns != 0) ++nf;
 634                 boxes_per_column = (nf / columns);
 635                 if (boxes_per_column < 1)
 636                         boxes_per_column = 1;
 637                 if (r1->Floor->AlphaN % boxes_per_column == 0)
 638                         return 2;
 639                 else
 640                         return 1;
 641         }
 642 }
 643
 644
 645 int CompareRooms(const folder *room1, const folder *room2)
 646 {
 647         if ((room1 == NULL) || (room2 == NULL))
 648                 return -1;
 649         return CompareRoomListByFloorRoomPrivFirst(room1, room2);
 650 }
 651
 652 int ConditionalRoomIsRESTSubRoom(StrBuf *Target, WCTemplputParams *TP)
 653 {
 654         wcsession  *WCC = WC;
 655         folder     *Folder = (folder *)CTX(CTX_ROOMS);
 656         HashPos    *it;
 657         StrBuf     * Dir;
 658         void       *vDir;
 659         long        len;
 660         const char *Key;
 661         int i, j, urlp;
 662         int delta;
 663
 664
 665         /* list only folders relative to the current floor... */
 666         if (Folder->Floor != WCC->CurrentFloor)
 667                 return 0;
 668
 669         urlp = GetCount(WCC->Directory);
 670         delta = Folder->nRoomNameParts - urlp + 1;
 671
 672         syslog(0, "\n->%s: %d - %ld ",
 673                ChrPtr(Folder->name),
 674                urlp,
 675                Folder->nRoomNameParts);
 676         /* list only the floors which are in relation to the dav_depth header */
 677         if (WCC->Hdr->HR.dav_depth != delta) {
 678                 syslog(0, "1\n");
 679                 return 0;
 680         }
 681
 682
 683         it = GetNewHashPos(WCC->Directory, 0);
 684         /* Fast forward the floorname we checked above... */
 685         GetNextHashPos(WCC->Directory, it, &len, &Key, &vDir);
 686
 687         if (Folder->nRoomNameParts > 1) {
 688                 for (i = 0, j = 1;
 689                      (i > Folder->nRoomNameParts) && (j > urlp);
 690                      i++, j++)
 691                 {
 692                         if (!GetNextHashPos(WCC->Directory,
 693                                             it, &len, &Key, &vDir) ||
 694                             (vDir == NULL))
 695                         {
 696                                 DeleteHashPos(&it);
 697
 698                                 syslog(0, "3\n");
 699                                 return 0;
 700                         }
 701                         Dir = (StrBuf*) vDir;
 702                         if (strcmp(ChrPtr(Folder->RoomNameParts[i]),
 703                                    ChrPtr(Dir)) != 0)
 704                         {
 705                                 DeleteHashPos(&it);
 706                                 syslog(0, "4\n");
 707                                 return 0;
 708                         }
 709                 }
 710                 DeleteHashPos(&it);
 711                 return 1;
 712         }
 713         else {
 714                 if (!GetNextHashPos(WCC->Directory,
 715                                     it, &len, &Key, &vDir) ||
 716                     (vDir == NULL))
 717                 {
 718                         DeleteHashPos(&it);
 719
 720                         syslog(0, "5\n");
 721                         return WCC->Hdr->HR.dav_depth == 1;
 722                 }
 723                 DeleteHashPos(&it);
 724                 Dir = (StrBuf*) vDir;
 725                 if (WCC->Hdr->HR.dav_depth == 0) {
 726                         return (strcmp(ChrPtr(Folder->name),
 727                                        ChrPtr(Dir))
 728                                 == 0);
 729
 730                 }
 731                 return 0;
 732         }
 733 }
 734
 735
 736 void
 737 InitModule_ROOMLIST
 738 (void)
 739 {
 740         /* we duplicate this, just to be shure its already done. */
 741         RegisterCTX(CTX_ROOMS);
 742         RegisterCTX(CTX_FLOORS);
 743
 744         RegisterIterator("ITERATE:THISROOM:WHO_KNOWS", 0, NULL, GetWhoKnowsHash, NULL, DeleteHash, CTX_STRBUF, CTX_NONE, IT_NOFLAG);
 745         RegisterIterator("ITERATE:THISROOM:GNET", 1, NULL, GetNetConfigHash, NULL, NULL, CTX_STRBUFARR, CTX_NONE, IT_NOFLAG);
 746         RegisterIterator("ITERATE:THISROOM:MALIAS", 1, NULL, GetThisRoomMAlias, NULL, NULL, CTX_STRBUF, CTX_NONE, IT_NOFLAG);
 747
 748         RegisterIterator("LFLR", 0, NULL, GetFloorListHash, NULL, NULL, CTX_FLOORS, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 749         RegisterIterator("LKRA", 0, NULL, GetRoomListHashLKRA, NULL, NULL, CTX_ROOMS, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 750         RegisterIterator("LZRM", 0, NULL, GetZappedRoomListHash, NULL, DeleteHash, CTX_ROOMS, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 751         RegisterIterator("LPRM", 0, NULL, GetRoomListHashLPRM, NULL, DeleteHash, CTX_ROOMS, CTX_NONE, IT_FLAG_DETECT_GROUPCHANGE);
 752
 753
 754
 755
 756         RegisterConditional("COND:ROOM:REST:ISSUBROOM", 0, ConditionalRoomIsRESTSubRoom, CTX_ROOMS);
 757
 758         RegisterSortFunc(HKEY("byfloorroom"),
 759                          NULL, 0,
 760                          CompareRoomListByFloorRoomPrivFirst,
 761                          CompareRoomListByFloorRoomPrivFirstRev,
 762                          GroupchangeRoomListByFloorRoomPrivFirst,
 763                          CTX_ROOMS);
 764
 765 }