wvprint/wvprint.cc

   1 /*
   2  * Worldvisions Weaver Software:
   3  *   Copyright (C) 1997-2004 Net Integration Technologies, Inc.
   4  *
   5  * This is the WvPrint intelligent print server class.
   6  */
   7
   8 #include <linux/lp.h>
   9
  10 #include "uniconf.h"
  11
  12 #include <pwd.h>
  13 #include <grp.h>
  14 #include <strutils.h>
  15 #include <wvstringtable.h>
  16 #include <wvaddr.h>
  17 #include <wvfile.h>
  18 #include <wvtcp.h>
  19 #include <sys/ioctl.h>
  20 #include <cups/cups.h>
  21 #include <uniconfdaemon.h>
  22 #include <unitempgen.h>
  23 #include <uniunwrapgen.h>
  24 #include "wvprint.h"
  25 #include "wvzeroconfbrowser.h"
  26 #include "wvprintconfwatcher.h"
  27 #include "wvprintcupsunigen.h"
  28 #include "wvremotecontrol.h"
  29
  30 #define LOCAL_QUEUE_NAME        "local"
  31 #define REMOTE_QUEUE_NAME       "remote"
  32
  33 #define DEFAULT_USER            "lp"
  34 #define DEFAULT_GROUP           "lp"
  35
  36 WvPrint::WvPrint(const UniConf _cfg, UniConf *_db, WvStringParm _log)
  37     : log(_log, WvLog::Debug5), cfg(_cfg["WvPrint"]),
  38       db(_db), aliases(16), cupsgen(NULL)
  39 {
  40     uses_continue_select = true;
  41     needs_autoconfigure_remote = false;
  42
  43     watches.add(cfg["lpdprobe"],
  44                 UniConfCallback(this, &WvPrint::lpdprobe_callback), false);
  45
  46     conf_watcher = new WvPrintConfWatcher(log, cfg);
  47     conf_watcher->set_cupsmanager(WvCUPSManager::get_instance());
  48
  49     /* This is a temporary sol'n and proves to have redundant checks
  50      *  It is used to check that when the aliases section has an alias
  51      *  added, it reconfigures all aliases, which then calls the callback
  52      *  AGAIN, and we want to stop it from calling the callback all the time
  53      */
  54     need_alias_config = true;
  55
  56     usbprobe = new WvStream;
  57     usbprobe->setcallback(usbprobe_callback, this);
  58     append(usbprobe, true);
  59
  60     WvFile *usbwatcher = new WvFile(WVPRINT_USBDEVICES, O_RDONLY);
  61     if (!usbwatcher->isok())
  62     {
  63         log(WvLog::Debug, "Error appending usbwatcher\n");
  64     }
  65
  66     /* Get rid of initial select() returning true */
  67     usbwatcher->select(0, true, true);
  68     usbwatcher->setcallback(usbwatcher_callback, usbprobe);
  69     append(usbwatcher, true);
  70
  71
  72     WvZeroconfBrowser *rendezvouswatcher = new WvZeroconfBrowser("_printer._tcp");
  73     rendezvouswatcher->setcallback(rendezvouswatcher_callback, this);
  74     append(rendezvouswatcher, true);
  75
  76     /* create and mount the CUPSUniGen */
  77     cupsgen = new WvPrintCUPSUniGen(conf_watcher);
  78     cupsgen->set_remote_controller(new WvPrintRemoteControl(this));
  79     cfg["status"].mountgen(cupsgen);
  80     /* we'll mount the already loaded UniConf */
  81     uniconf["/"].mountgen(new UniUnwrapGen(cfg["status"]));
  82
  83     UniConfDaemon *daemon = new UniConfDaemon(uniconf, false, NULL);
  84     daemon->setupunixsocket("/tmp/wvprintd-uniconf", 0700);
  85     WvIStreamList::globallist.append(daemon, true);
  86
  87     conf_watcher->init_config();
  88 }
  89
  90 WvPrint::~WvPrint()
  91 {
  92     terminate_continue_select();
  93     delete conf_watcher;
  94 }
  95
  96
  97 void WvPrint::configure_aliases()
  98 {
  99 #if 0
 100     need_alias_config = false;
 101
 102     /* easier to iterate through the keys and make a new alias table
 103        in case some have changed */
 104     aliases.zap();
 105     PrintQueueNameDict::Iter qit(queues);
 106
 107     WvString defaultQueue(cfg["/aliases/lp"].getme(""));
 108
 109     /* Setup default queue */
 110     if (!defaultQueue || !queues[defaultQueue])
 111     {
 112         WvString newlpqueue("");
 113         cfg["/aliases/lp"].remove();
 114
 115         /* Ensure that if a local queue exists that the lp default
 116          * queue points to it, else default to the remote queue */
 117         bool remoteQueue = true;
 118
 119         for (qit.rewind(); qit.next(); )
 120         {
 121             /* prefer a local queue to a remote one */
 122             UniConf section = cfg["queues"][qit->name];
 123
 124             if (section.exists() &&
 125                   !!section.getme(""))
 126             {
 127                 newlpqueue = qit->name;
 128                 remoteQueue = false;
 129                 break;
 130             }
 131             else if (section.exists() &&
 132                         section["networkprinter"].getmeint(0))
 133             {
 134                 if (remoteQueue)
 135                     newlpqueue = qit->name;
 136             }
 137
 138             /* otherwise prefer first in lexicographical order,
 139              *  don't reference another alias by default */
 140             if ((! newlpqueue || strcasecmp(qit->name, newlpqueue) < 0)
 141                     && !qit->alias)
 142                 newlpqueue = qit->name;
 143         }
 144
 145         if (!!newlpqueue)
 146         {
 147             cfg["/aliases/lp"].setme(newlpqueue);
 148             aliases.add(new AliasMap("lp", newlpqueue), true);
 149         }
 150     }
 151     else
 152         aliases.add(new AliasMap("lp", defaultQueue), true);
 153
 154     /* Map aliases to entries */
 155     UniConf::Iter cfgit(cfg["/aliases"]);
 156     WvStringList removeList; // FIXME : Workaround for uniconf bug, deleting
 157
 158     for (cfgit.rewind(); cfgit.next(); )
 159     {
 160         WvString aliasEnt = cfgit().key().printable();
 161         WvString queuename = cfgit().getme("");
 162
 163         /* Don't bother dealing with the default queue */
 164         if (!!queuename)
 165         {
 166             /* Don't map to unexisting queues */
 167             if (queues[queuename])
 168                 aliases.add(new AliasMap(aliasEnt, queuename), true);
 169             else
 170             {
 171                 log(WvLog::Debug1,
 172                         "Found an alias for which no queue exists (%s->%s)!\n",
 173                         aliasEnt, queuename);
 174                 cfg["aliases"][aliasEnt].remove();
 175             }
 176         }
 177         else
 178         {
 179             log(WvLog::Debug, "No alias entry set for (%s->%s)\n",
 180                             aliasEnt, queuename);
 181         }
 182     }
 183
 184     AliasMapDict::Iter aliasit(aliases);
 185     for (aliasit.rewind(); aliasit.next(); )
 186     {
 187         PrintQueueName* queue = queues[aliasit().queue];
 188         if (queue && ! queues[aliasit().alias])
 189         {
 190             log(WvLog::Debug, "Setting up alias %s to %s\n",
 191                 aliasit().alias, queue->name);
 192             queues.add(new PrintQueueName(aliasit().alias,
 193                 queue->queue, true), true);
 194         }
 195     }
 196
 197     need_alias_config = true;
 198 #endif
 199 }
 200
 201 void WvPrint::start_queues()
 202 {
 203 }
 204
 205
 206 bool WvPrint::isok() const
 207 {
 208     return !(isempty());
 209 }
 210
 211 bool WvPrint::give_up_root()
 212 {
 213     WvString       user;
 214     WvString       group;
 215     struct passwd *pwd;
 216     struct group  *grp;
 217
 218     group = cfg["group"].getme(DEFAULT_GROUP);
 219     grp = getgrnam(group);
 220
 221     if (!grp)
 222     {
 223         log(WvLog::Warning, "Unknown group %s\n", group);
 224         return false;
 225     }
 226
 227     if (setregid(grp->gr_gid, grp->gr_gid) == -1)
 228         log(WvLog::Warning, "Unable to set group to \"%s\": %s\n",
 229             grp->gr_name, strerror(errno));
 230
 231     user = cfg["user"].getme(DEFAULT_USER);
 232     pwd = getpwnam(user);
 233
 234     if (!pwd)
 235     {
 236         log(WvLog::Warning, "Unknown user %s\n", user);
 237         return false;
 238     }
 239
 240     if (setreuid(pwd->pw_uid, pwd->pw_uid) == -1)
 241         log(WvLog::Warning, "Unable to set user to \"%s\": %s\n",
 242             pwd->pw_name, strerror(errno));
 243
 244     return true;
 245 }
 246
 247
 248 void WvPrint::zap_configuration(bool only_empty_sections)
 249 {
 250     UniConf::Iter i(cfg["/queues"]);
 251     WvStringList removeQueues;
 252
 253     for (i.rewind(); i.next(); )
 254     {
 255         if (i().key().isempty() ||
 256                 (i()["autoprobed"].getmeint(0) && !only_empty_sections))
 257         {
 258             removeQueues.append(new WvString(i().key().printable()), true);
 259         }
 260     }
 261
 262     /* Just remove all the bloody aliases */
 263     /* FIXME : Another major one */
 264     //UniConf::Iter j(cfg[cfgRoot "/aliases"]);
 265     //for (j.rewind(); j.next(); )
 266     //  j().key().remove();
 267 }
 268
 269 void WvPrint::autoconfigure()
 270 {
 271     zap_configuration(true);
 272
 273     autoconfigure_local();
 274     begin_autoconfigure_remote();
 275 }
 276
 277 void WvPrint::autoconfigure_local()
 278 {
 279     log(WvLog::Debug, "Attempting to autoconfigure local printers\n");
 280
 281     /* Probe for parallel printers */
 282     probe_parallel();
 283
 284     /* Probe for USB printers */
 285     probe_usb();
 286 }
 287
 288 bool WvPrint::probe_parallel()
 289 {
 290     WvString device;
 291
 292     for (int i=0; i<1; i++)
 293     {
 294         device = WvString("/dev/lp%s", i);
 295         if (probe_local_device(device) != -1)
 296             autoconfigure_local_parallel(device, i);
 297     }
 298
 299     return true;
 300 }
 301
 302
 303 bool WvPrint::probe_lpd()
 304 {
 305     configure_remote_lpd(cfg["netprobe/netprintip"].getme(""),
 306                          cfg["netprobe/netprintdesc"].getme(""),
 307                          "Network Printer", cfg["netprobe/netprintqueue"].getme(""));
 308     return true;
 309 }
 310
 311 void WvPrint::usbprobe_callback(WvStream &s, void *userdata)
 312 {
 313     WvPrint *print = static_cast<WvPrint *>(userdata);
 314     print->probe_usb();
 315 }
 316
 317
 318 void WvPrint::usbwatcher_callback(WvStream &s, void *userdata)
 319 {
 320     WvStream *probe = static_cast<WvStream *>(userdata);
 321
 322     /* FIXME:
 323      * Invoke a USB probe in 1 second. After the /proc/bus/usb/devices file
 324      * is updated it takes time for /dev/usblp[x] to become attached (or
 325      * detached as the case may be).
 326      */
 327     probe->alarm(2000);
 328 }
 329
 330 /**
 331    Callback to watch for Zeroconf events.
 332  */
 333 void WvPrint::rendezvouswatcher_callback(WvStream &s, void *userdata)
 334 {
 335     WvPrint *print = static_cast<WvPrint *>(userdata);
 336     WvZeroconfBrowser *watcher = static_cast<WvZeroconfBrowser*>(&s);
 337
 338     print->log(WvLog::Debug1, "rendezvouswatcher_callback(), %s\n", watcher->isempty());
 339
 340     if (!watcher->isempty())
 341     {
 342         print->probe_zeroconf(watcher);
 343     }
 344 }
 345
 346
 347 bool WvPrint::probe_usb()
 348 {
 349     WvString device;
 350     WvString device_fmt = "/dev/usblp%s";
 351
 352     {
 353         WvFile devfile(WvString(device_fmt, 0), O_RDONLY);
 354         if (!devfile.isok())
 355         {
 356             device_fmt = "/dev/usb/lp%s";
 357             WvFile devfile(WvString(device_fmt, 0), O_RDONLY);
 358             if(!devfile.isok())
 359             {
 360                 device_fmt = "";
 361             }
 362         }
 363     }
 364
 365     // currently limit to the first 16 USB devices found
 366     // TODO: check this value somewhere, I know we can do
 367     // that.
 368     if (!!device_fmt)
 369     {
 370         for (int i=0; i<16; i++)
 371         {
 372             device = WvString(device_fmt, i);
 373             if (probe_local_device(device) == -1)
 374             {
 375                 continue;
 376             }
 377             autoconfigure_local_usb(device, i);
 378         }
 379     }
 380
 381     kill_dead_queues();
 382
 383     return true;
 384 }
 385
 386 void WvPrint::kill_dead_queues()
 387 {
 388     UniConf::Iter i(cfg["/queues"]);
 389     WvString device;
 390     WvString lpdserver;
 391     WvStringList deadqueue;
 392
 393     for (i.rewind(); i.next(); )
 394     {
 395         device = i()["device"].getme(WvString::null);
 396         lpdserver = i()["lpdserver"].getme(WvString::null);
 397
 398         if (!!device)
 399         {
 400             if (probe_local_device(device) == -1)
 401                 deadqueue.append(new WvString(i().key().printable()), true);
 402         }
 403         else if (!!lpdserver)
 404         {
 405             // FIXME: Figure out what whoever wrote this meant
 406             // to do, and didn't.
 407         }
 408         else
 409         {
 410             log(WvLog::Debug, "Removing: %s", i().key().printable());
 411             /* What the hell is this connected to? */
 412             deadqueue.append(new WvString(i().key().printable()), true);
 413         }
 414     }
 415
 416     // FIXME:
 417     // Eventually, when the UniTempGen Iterators don't explode
 418     // when you delete the keys while iterating, this won't be necessary
 419     WvStringList::Iter i2(deadqueue);
 420     for (i2.rewind(); i2.next(); )
 421         remove_queue(*i2);
 422 }
 423
 424 int WvPrint::probe_local_device(WvStringParm device)
 425 {
 426     int fd;
 427
 428     fd = open(device, O_RDONLY|O_NOCTTY|O_TRUNC|O_NONBLOCK);
 429     if (fd == -1)
 430     {
 431         log(WvLog::Debug, "Unable to open %s for probing: %s\n",
 432                         device, strerror(errno));
 433         return -1;
 434     }
 435
 436     int status = 0;
 437     if (ioctl(fd, LPGETSTATUS, &status) == -1)
 438     {
 439         log(WvLog::Debug, "Unable to get printer status: %s\n",
 440                 strerror(errno));
 441         ::close(fd);
 442         return -1;
 443     }
 444
 445     ::close(fd);
 446
 447     /* Parallel printers have LP_PBUSY set when they're ready and USB ones
 448      * have LP_PACK unset.
 449      */
 450     if (!(status & LP_PBUSY) && (status & LP_PACK))
 451     {
 452         log(WvLog::Info,
 453             "No device on printer port, is your printer turned on?\n");
 454         return -1;
 455     }
 456
 457     return 0;
 458 }
 459
 460 void WvPrint::autoconfigure_local_parallel(WvStringParm device, int index)
 461 {
 462     WvFile* file;
 463     WvString ieee1284_info;
 464     WvStringList lines;
 465     WvString ieee_class;
 466     WvString ieee_manufacturer;
 467     WvString ieee_model;
 468     WvString ieee_description;
 469     WvStringList ieee_commandset;
 470     WvString printertype;
 471     WvStringList::Iter j(lines);
 472     char autoprobe_file[256];
 473
 474     log(WvLog::Debug, "Configuring local parallel printer on %s\n", device);
 475
 476     sprintf(autoprobe_file, WVPRINT_IEEE1284, index);
 477     file = new WvFile(autoprobe_file, O_RDONLY);
 478
 479     if (!file->isok())
 480     {
 481         log(WvLog::Info, "Could not read IEEE 1284 device information\n");
 482         return;
 483     }
 484
 485     while (file->isok())
 486     {
 487         char* str;
 488
 489         str = file->getline();
 490         if (str)
 491         {
 492             str = trim_string(str);
 493             ieee1284_info.append(str);
 494         }
 495     }
 496
 497     WVRELEASE(file);
 498
 499     ieee_commandset.zap();
 500
 501     lines.split(ieee1284_info, ";\n");
 502     j.rewind();
 503     while (j.next())
 504     {
 505         WvStringList info;
 506
 507         if (!j())
 508             continue;
 509
 510         info.split(j(), ":", 2);
 511
 512         if (info.count() != 2)
 513             log(WvLog::Debug, "Malformed IEEE 1284 device information line\n");
 514
 515         if (*(info.first()) == "CLASS")
 516             ieee_class = *(info.last());
 517
 518         if (*(info.first()) == "MANUFACTURER")
 519             ieee_manufacturer = *(info.last());
 520
 521         if (*(info.first()) == "MODEL")
 522             ieee_model = *(info.last());
 523
 524         if (*(info.first()) == "DESCRIPTION")
 525             ieee_description = *(info.last());
 526
 527         if (*(info.first()) == "COMMAND SET")
 528         {
 529             ieee_commandset.split(*(info.last()), ", ");
 530         }
 531     }
 532
 533     if (ieee1284_info && !!ieee_class && ieee_class != "PRINTER")
 534     {
 535         log(WvLog::Debug2,
 536             "IEEE-1284 autodetection found a non-printer device\n");
 537         return;
 538     }
 539
 540     if (!!ieee_manufacturer && !!ieee_model)
 541         printertype = WvString("%s %s", ieee_manufacturer, ieee_model);
 542
 543     if (!ieee_description)
 544         ieee_description = printertype;
 545
 546     if (!!printertype)
 547         ieee_commandset.prepend(&printertype, false);
 548
 549     if (!!ieee_manufacturer)
 550         ieee_commandset.append(&ieee_manufacturer, false);
 551
 552     printertype = ieee_commandset.join(";");
 553
 554     write_local_config("parallel", device, printertype, ieee_description);
 555 }
 556
 557 void WvPrint::autoconfigure_local_usb(WvStringParm device, int index)
 558 {
 559     WvString printertype;
 560     WvString description;
 561     char *line, *ptr;
 562     WvString vendor, prodID, rev;
 563     WvString manufacturer, product, serialnumber;
 564     bool device_found = false;
 565     int num_device_found = 0;
 566
 567     log(WvLog::Debug, "Configuring local USB printer for device %s\n", device);
 568
 569     WvFile file(WVPRINT_USBDEVICES, O_RDONLY);
 570
 571     /* Skip select because it's a proc file */
 572     file.skip_select = true;
 573
 574     if (!file.isok())
 575     {
 576         log(WvLog::Info, "Could not read USB device information\n");
 577         return;
 578     }
 579
 580     /* This working loop depends on the fact that the USB devices file is
 581      * formatted like this for each printer entry (which it should be unless
 582      * some big changes happen to the way USB printers are handled):
 583      *  ...
 584      *  P:  Vendor=xxx ProdID=xxx Rev=xxx
 585      *  S: Manufacturer=xxx
 586      *  S: Product=xxx
 587      *  S: SerialNumber=xxx
 588      *  ...
 589      *  I: ... Driver=usblp
 590      *  ...
 591      */
 592     while (file.isok())
 593     {
 594         line = file.blocking_getline(-1);
 595         if (!line)
 596             continue;
 597
 598         if (!strncmp(line, "T:", 2))
 599         {
 600             // device has been found.
 601             device_found = true;
 602             log(WvLog::Debug, "Found a T: line\n");
 603             // re-init internal state.
 604             vendor = prodID = rev = "";
 605             manufacturer = product = serialnumber = "";
 606             description = printertype = "";
 607        }
 608         else if (device_found)
 609         {
 610             if (!strncmp(line, "P:", 2))
 611             {
 612                 char *tmp;
 613
 614                 ptr = strstr(line, "Rev=");
 615                 if (ptr) ptr += sizeof("Rev=")-1;
 616                 rev = ptr;
 617
 618                 ptr = strstr(line, "ProdID=");
 619                 if (ptr) ptr += sizeof("ProdID=")-1;
 620                 tmp = strchr(ptr, ' ');
 621                 *tmp = '\0';
 622                 prodID = ptr;
 623
 624                 ptr = strstr(line, "Vendor=");
 625                 if (ptr) ptr += sizeof("Vendor=")-1;
 626                 tmp = strchr(ptr, ' ');
 627                 *tmp = '\0';
 628                 vendor = ptr;
 629             }
 630             else if (!strncmp(line, "S:", 2))
 631             {
 632                 if (strstr(line, "Manufacturer="))
 633                 {
 634                     ptr = strstr(line, "Manufacturer=");
 635                     ptr += sizeof("Manufacturer=")-1;
 636                     manufacturer = ptr;
 637                 }
 638                 else if (strstr(line, "Product="))
 639                 {
 640                     ptr = strstr(line, "Product=");
 641                     ptr += sizeof("Product=")-1;
 642                     product = ptr;
 643                 }
 644                 else if (strstr(line, "SerialNumber="))
 645                 {
 646                     ptr = strstr(line, "SerialNumber=");
 647                     ptr += sizeof("SerialNumber=")-1;
 648                     serialnumber = ptr;
 649                 }
 650             }
 651             else if (!strncmp(line, "I:", 2))
 652             {
 653                 log(WvLog::Debug, "Found a I: line %s\n", line);
 654
 655                 if (strstr(line, "Driver=usblp") || strstr(line, "Driver=printer"))
 656                 {
 657                     if (num_device_found == index)
 658                     {
 659                         printertype = WvString("%s %s", manufacturer, product);
 660                         description = printertype;
 661                         printertype.append(";", false);
 662                         printertype.append(manufacturer, false);
 663
 664                         // we must look up for the device
 665
 666                         log(WvLog::Debug, "write local config for printer %s on device %s\n",
 667                             printertype, device);
 668
 669                         write_local_config("usb", device, printertype, description);
 670                     }
 671                     num_device_found++;
 672                 }
 673                 // we handled the device info. reset until the next ^T: line.
 674                 device_found = false;
 675             }
 676         }
 677     }
 678 }
 679
 680 void WvPrint::write_local_config(WvStringParm port, WvStringParm device, WvStringParm printer,
 681                 WvStringParm description)
 682 {
 683     UniConf::Iter i(cfg["queues"]);
 684     UniConf unisect;
 685     WvString queuename;
 686     unsigned int queuenumber;
 687     bool reconfig;
 688
 689     for (i.rewind(); i.next(); )
 690     {
 691         if (strcmp(i()["device"].getme(""), device) == 0)
 692         {
 693             queuename = i().key().printable();
 694             break;
 695         }
 696     }
 697
 698     if (!queuename)
 699     {
 700         queuenumber = 0;
 701         queuename = WvString(LOCAL_QUEUE_NAME "%s", queuenumber);
 702         UniConf section = cfg["queues"][queuename];
 703
 704         while (section.exists())
 705         {
 706             queuename = WvString(LOCAL_QUEUE_NAME "%s", queuenumber++);
 707             section = cfg["queues"][queuename];
 708         }
 709
 710     }
 711
 712     unisect = cfg["queues"][queuename];
 713
 714     reconfig = false;
 715     reconfig |= !(unisect.exists());
 716     reconfig |= !!printer
 717         && (unisect["printer"].getme(WvString::null) != printer);
 718
 719     unisect["device"].setme(device);
 720     unisect["port"].setme(port);
 721
 722     if (reconfig)
 723     {
 724         log(WvLog::Debug, "Got reconfig\n");
 725         configure_queue(queuename, printer, description);
 726
 727         /* FIXME: this is a temporary fix for some /dev/lp0 silliness. */
 728         unisect["filter"].setme("/bin/cat");
 729
 730         /* We will auto create/delete this queue */
 731         unisect["autoprobed"].setmeint(1);
 732     }
 733 }
 734
 735 /*
 736  * Although remote queues already work, only NET Integrator forwarding is
 737  * supported we now want remote queues to be added as well with a prefix
 738  * of REMOTE_QUEUE_NAME to be added, as long as the name resolves, we'll
 739  * assume that this printer is ready to go
 740  */
 741 void WvPrint::configure_remote_lpd(WvStringParm _serveraddr,
 742                                    WvStringParm _description,
 743                                    WvStringParm _printertype,
 744                                    WvStringParm _remotequeue)
 745 {
 746     WvTCPConn* conn;
 747     WvString serveraddr = _serveraddr;
 748
 749     log(WvLog::Debug, "DEBUG: configure_remote_lpd(%s, %s, %s, %s)\n",
 750         _serveraddr, _description, _printertype, _remotequeue);
 751
 752     if (!strchr(_serveraddr, ':'))
 753         serveraddr.append(":515");
 754
 755     log(WvLog::Debug, "DEBUG: connecting to %s\n", serveraddr);
 756 #if 1
 757     conn = new WvTCPConn(serveraddr);
 758
 759     log(WvLog::Debug, "DEBUG: conn created\n");
 760
 761     append(conn, true);
 762     log(WvLog::Debug, "DEBUG: conn append\n");
 763     conn->alarm(10000);  /* negotiation takes awhile when the server is bogged */
 764     log(WvLog::Debug, "DEBUG: conn->alarm()\n");
 765     printerInfo *pInfo = new printerInfo(serveraddr, _description, _printertype, _remotequeue);
 766
 767     conn->setcallback(WvStreamCallback(this,
 768                             &WvPrint::state_remotelpd_resolve), pInfo);
 769
 770     /* this state will only be called on a connection error, if the
 771      *   connection completes we will erase this callback */
 772     conn->setclosecallback(WvBoundCallback<IWvStreamCallback, printerInfo*>(
 773                                this, &WvPrint::state_connect_error, pInfo));
 774 #endif
 775 }
 776
 777 /*
 778  * State only encountered when a TCP Connection to a remote printer dies.
 779  *   Used so that we can append the failed connection to a list of errors
 780  *   for webconfig to periodically check on
 781  */
 782 void WvPrint::state_connect_error(printerInfo *pInfo, WvStream &s)
 783 {
 784     log(WvLog::Debug, "DEBUG: state_connect_error\n");
 785
 786     remoteLpdErrors.append(new WvString("Error connecting to printer '%s'",
 787                                         pInfo->description), true);
 788
 789     if (pInfo)
 790         delete pInfo;
 791 }
 792
 793 void WvPrint::state_remotelpd_resolve(WvStream &s, void *userdata)
 794 {
 795     unsigned int queuenumber;
 796     WvString queuename;
 797     UniConf  unisect;
 798     bool reconfigure;
 799
 800     log(WvLog::Debug, "DEBUG: state_remotelpd_resolve\n");
 801
 802     printerInfo *pInfo = (printerInfo*)userdata;
 803
 804     /* no longer need to get to the now declared 'error' state when it closes. */
 805     s.setclosecallback(0);
 806
 807     /*
 808      * If we haven't established a connection, quit, this should also
 809      *  be changed to include else if (the printer doesn't talk lpd)
 810      */
 811     if (s.alarm_was_ticking)
 812     {
 813         log(WvLog::Error, "Error adding Network Printer %s\n", pInfo->address);
 814         s.close();
 815         return;
 816     }
 817
 818     s.close();
 819
 820     /* Server appears to be responding, find a suitable queuename for it
 821         check for the existance of this queue, possibly for a writeover */
 822     UniConf::Iter i(cfg["queues"]);
 823     for (i.rewind(); i.next(); )
 824     {
 825         if (strcmp(i()["remotehost"].getme(""), pInfo->address) == 0)
 826         {
 827             queuename = i().key().printable();
 828             break;
 829         }
 830     }
 831
 832     log(WvLog::Debug, "DEBUG: state_remotelpd_resolve found queue: %s\n", queuename);
 833
 834     if (!queuename)
 835     {
 836         queuenumber = 0;
 837         queuename   = WvString(REMOTE_QUEUE_NAME "%s", queuenumber);
 838
 839         UniConf section(cfg["queues"][queuename]);
 840
 841         while (section.exists())
 842         {
 843             queuename = WvString(REMOTE_QUEUE_NAME "%s", queuenumber++);
 844             section   = cfg["queues"][queuename];
 845         }
 846     }
 847
 848     reconfigure = false;
 849     unisect = cfg["queues"][queuename];
 850
 851     if (unisect.exists())
 852     {
 853         configure_queue(queuename, unisect["printer"].getme(""),
 854                       pInfo->description);
 855     }
 856     else
 857         configure_queue(queuename, pInfo->type, pInfo->description);
 858
 859     /* As before we'll use lpdserver to indicate the server,
 860      *   but we'll use a network printer flag to indicate it's
 861      *   not a Net Integrator bounce
 862      */
 863     unisect["autoprobed"].setmeint(0);
 864     unisect["networkprinter"].setmeint(1);
 865     unisect["lpdserver"].setme(pInfo->address);
 866     unisect["queue"].setme(pInfo->remotequeue);
 867
 868     unisect["device"].setme(WvString("//%s/%s", pInfo->address, pInfo->remotequeue));
 869     unisect["port"].setme("lpd");
 870
 871     log(WvLog::Debug5, "state_remotelpd_resolve(): lpd URI is lpd://%s/%s", pInfo->address, pInfo->remotequeue);
 872
 873     /* Again hiding semantics of the filters we use, a definite fix-me
 874         Apparantely wvprint.ids is there, but not used. ah, ah, YET! */
 875     unisect["filter"].setme("/bin/cat");
 876
 877     if (pInfo)
 878         delete pInfo;
 879 }
 880
 881
 882 void WvPrint::autoconfigure_lpd(WvStringParm _serveraddr)
 883 {
 884     WvStringList queuelist;
 885     WvStringList::Iter i(queuelist);
 886     WvStringList queueinfo;
 887     WvString sectionname = "";
 888     WvString lserveraddr = "";
 889     WvString lqueuename = "";
 890     WvString queuename = "";
 891     WvString remotequeue = "";
 892     WvString printertype = "";
 893     WvString description = "";
 894     WvString serveraddr = _serveraddr;
 895     WvTCPConn* conn;
 896     bool reconfig;
 897
 898     log(WvLog::Debug,
 899         "Attempting to autoconfigure from WvPrint LPD server %s\n",
 900         serveraddr);
 901
 902     if (!strchr(serveraddr, ':'))
 903         serveraddr.append(":printer");
 904
 905     conn = new WvTCPConn(serveraddr);
 906
 907     conn->print("\1"WVPRINT_MAGIC_PROBE"\n");
 908     append(conn, false);
 909
 910     while (isok() && conn->isok())
 911     {
 912         WvString str = conn->getline();
 913
 914         if (!!str)
 915             queuelist.append(new WvString("%s", trim_string(str.edit())), true);
 916         else
 917         {
 918             // FIXME: got to be a better way than using an explicit timeout.
 919             // (No, letting getline handle it isn't a better way: you'd need to
 920             // set uses_continue_select on the WvTCPConn, which then crashes
 921             // since it's not in an execute loop.)
 922             // FIXME: Also, this crashes on exit (call_ctx assertion)
 923             continue_select(1000);
 924             WvIStreamList::execute();
 925         }
 926     }
 927
 928     unlink(conn);
 929
 930     if (conn->geterr())
 931     {
 932         log(WvLog::Notice, "Error connecting to %s: %s\n", _serveraddr,
 933                 conn->errstr());
 934         conn->close();
 935         WVRELEASE(conn);
 936         return;
 937     }
 938
 939     conn->close();
 940     WVRELEASE(conn);
 941
 942     if (!queuelist.isempty() && *queuelist.first() == WVPRINT_MAGIC_PROBE)
 943         queuelist.unlink_first();
 944     else
 945     {
 946         log(WvLog::Notice, "Server %s is not a WvPrint LPD server\n",
 947             _serveraddr);
 948         return;
 949     }
 950
 951     i.rewind();
 952     while (i.next())
 953     {
 954         queueinfo.zap();
 955
 956         /* FIXME: if you have a colon in a queue name or printer type,
 957          * *kaboom*. */
 958         queueinfo.split(i(), ":", 3);
 959
 960         if (queueinfo.isempty())
 961             break;
 962
 963         remotequeue = trim_string(queueinfo.first()->edit());
 964         queuename = WvString("%s-%s", _serveraddr, remotequeue);
 965         queueinfo.unlink_first();
 966
 967         if (!queueinfo.isempty())
 968         {
 969             printertype = trim_string(queueinfo.first()->edit());
 970             queueinfo.unlink_first();
 971
 972             if (!printertype)
 973                 printertype = WvString::null;
 974         }
 975         else
 976             printertype = WvString::null;
 977
 978         if (!queueinfo.isempty())
 979         {
 980             description = trim_string(queueinfo.first()->edit());
 981             queueinfo.unlink_first();
 982             if (!description)
 983                 description = WvString::null;
 984         }
 985         else
 986             description = WvString::null;
 987
 988         if (!description)
 989             description = printertype;
 990
 991         sectionname = WvString("queues/%s", queuename);
 992
 993         if (!cfg[sectionname].isnull())
 994         {
 995             lserveraddr = cfg[sectionname]["lpdserver"].getme(WvString::null);
 996             lqueuename = cfg[sectionname]["queue"].getme(remotequeue);
 997
 998             if (!lserveraddr
 999                 || lserveraddr != serveraddr
1000                 || lqueuename != queuename)
1001             {
1002                 break;
1003             }
1004         }
1005
1006         reconfig = false;
1007         reconfig |= cfg[sectionname].exists();
1008         if (printertype)
1009             reconfig |= cfg[sectionname]["printer"].getme(WvString::null) != printertype;
1010
1011         if (reconfig)
1012         {
1013             configure_queue(queuename, printertype, description);
1014
1015             if (serveraddr != _serveraddr)
1016                 cfg[sectionname]["lpdserver"].setme(_serveraddr);
1017             else
1018                 cfg[sectionname]["lpdserver"].setme(serveraddr);
1019
1020             cfg[sectionname]["queue"].setme(remotequeue);
1021
1022             /* We will auto create/delete this queue */
1023             cfg[sectionname]["autoprobed"].setmeint(1);
1024
1025             cfg[sectionname]["device"].setme(WvString("//%s/%s", _serveraddr, remotequeue));
1026             cfg[sectionname]["port"].setme("lpd");
1027
1028             log(WvLog::Debug5, "autoconfigure_lpd(): lpd URI is lpd://%s/%s", _serveraddr, remotequeue);
1029         }
1030     }
1031 }
1032
1033 void WvPrint::configure_queue(WvStringParm queue,
1034                               WvStringParm printertype,
1035                               WvString description)
1036 {
1037     UniConf config;
1038     WvStringList types;
1039     WvString sectionname("queues/%s", queue);
1040
1041     types.split(printertype, ";");
1042
1043     if (db)
1044     {
1045         UniConf pdb = *db;
1046         WvStringList::Iter i(types);
1047
1048         i.rewind();
1049         while( i.next() )
1050         {
1051             if( pdb[i()].getme() )
1052             {
1053                 log("found config for type %s\n", i());
1054                 config = pdb[i()];
1055                 break;
1056             }
1057         }
1058
1059         if (!config.isnull())
1060         {
1061             description = config["description"].getme(description);
1062         }
1063     }
1064
1065     if (!!description)
1066         log(WvLog::Notice, "Configuring %s as a %s\n", queue,
1067             description);
1068     else
1069         log(WvLog::Warning,
1070             "Configuring %s as an UNRECOGNIZED printer\n", queue);
1071
1072     if (!!printertype && config.isnull() && db)
1073         log(WvLog::Warning, "Printer type %s is unknown\n",
1074             description);
1075
1076     if (cfg[sectionname].exists())
1077         cfg[sectionname].remove();
1078
1079     cfg[sectionname]["printer"].setme(printertype);
1080     cfg[sectionname]["description"].setme(description);
1081
1082     log(WvLog::Notice, "Getting printer type as %s (%s)", printertype,
1083                     cfg[sectionname]["printer"].getme(""));
1084
1085     if (!config.isnull())
1086     {
1087         UniConf::Iter i(config);
1088
1089         i.rewind();
1090         while (i.next())
1091             cfg[sectionname][i().key()].setme(i().getme());
1092     }
1093
1094     log(WvLog::Debug, "Done configuring queues.\n");
1095 }
1096
1097 void WvPrint::advertise_queues(const AdvertiseQueueCallback& cb)
1098 {
1099     UniConf::Iter i(cfg["aliases"]);
1100     UniConf::Iter j(cfg["queues"]);
1101
1102     /* Advertise aliases */
1103     for (i.rewind(); i.next(); )
1104     {
1105         WvString alias = i().key().printable();
1106         WvString sect("aliases/%s", alias);
1107         WvString realprinter = cfg[sect].getme("");
1108
1109         UniConf s = cfg[WvString("queues/%s", realprinter)];
1110         if (s.exists() && !!alias)
1111         {
1112             cb(alias,
1113             WvString(s["advertise printer"].getme(s["printer"].getme(WvString::null))),
1114             WvString(s["description"].getme(WvString::null)));
1115         }
1116         else
1117         {
1118             // UniConf fixme, cannot remove while iterating
1119             log(WvLog::Warning, "Invalid alias, removing %s\n", alias);
1120         }
1121     }
1122
1123     /* Advertise Queues */
1124     for (j.rewind(); j.next(); )
1125     {
1126         WvString queue(j().key().printable());
1127         WvString sect("queues/%s", queue);
1128
1129         UniConf queuename = cfg[sect];
1130         cb(queue,
1131             WvString(queuename["advertise printer"].getme(queuename["printer"].getme(WvString::null))),
1132             WvString(queuename["description"].getme(WvString::null)));
1133     }
1134
1135     cb(WvString(), WvString(), WvString());
1136 }
1137
1138 void WvPrint::begin_autoconfigure_remote()
1139 {
1140     needs_autoconfigure_remote = true;
1141     alarm(0); /* trigger on next select */
1142 }
1143
1144 void WvPrint::execute_autoconfigure_remote()
1145 {
1146     WvStringList l;
1147     l.split(cfg["lpdprobe"].getme(""));
1148     WvStringList::Iter it(l);
1149
1150     /* add new lpd queues */
1151     for (it.rewind(); it.next(); )
1152     {
1153         if (!!it())
1154             autoconfigure_lpd(it());
1155     }
1156 }
1157
1158 void WvPrint::execute()
1159 {
1160     WvIStreamList::execute();
1161
1162     /* may do a continue_select */
1163     if (needs_autoconfigure_remote)
1164         execute_autoconfigure_remote();
1165     needs_autoconfigure_remote = false;
1166 }
1167
1168 void WvPrint::lpdprobe_callback(const UniConf &cfg, const UniConfKey &key)
1169 {
1170     begin_autoconfigure_remote();
1171 }
1172
1173
1174 bool WvPrint::is_alias(WvStringParm queuename)
1175 {
1176     if (cfg[WvString("aliases/%s", queuename)].exists())
1177     {
1178         return true;
1179     }
1180     return false;
1181 }
1182
1183 void WvPrint::remove_queue(WvStringParm queuename)
1184 {
1185     if (!!queuename)
1186     {
1187         cfg["queues"][queuename].setme(WvString::null);
1188     }
1189 }
1190
1191 #warning REMOVE
1192 #if 0
1193 PrintQueue* WvPrint::get_queue(WvStringParm aQueue)
1194 {
1195     if (queues[aQueue])
1196         return queues[aQueue]->queue;
1197     else
1198         return 0;
1199 }
1200 #endif
1201
1202
1203
1204 bool WvPrint::probe_zeroconf(WvZeroconfBrowser* browser)
1205 {
1206     if (browser->isok())
1207     {
1208         WvZeroconfService *service;
1209
1210         while (!browser->isempty())
1211         {
1212             service = browser->pop_first_service();
1213             if (service)
1214             {
1215                 log("Found service %s of type %s\n", service->name, service->type);
1216
1217                 delete service;
1218             }
1219         }
1220     }
1221     return true;
1222 }