@esslassi/electron-printer 0.0.6 → 0.0.8

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@esslassi/electron-printer",
   "description": "Node.js and Electron bindings",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "main": "./lib/index.js",
   "private": false,
   "scripts": {

package/src/linux_printer.cpp

@@ -1,171 +1,371 @@
 #include "linux_printer.h"
+
 #include <cups/cups.h>
 #include <cups/ppd.h>
+#include <cups/ipp.h>
+#include <cups/http.h>
+
+#include <vector>
+#include <string>
+#include <map>
+#include <fstream>
+#include <algorithm>
+#include <unistd.h>
+#include <cstring>
+
+/* =========================================================
+   Helpers
+========================================================= */
 
-std::string LinuxPrinter::GetPrinterStatus(ipp_pstate_t state)
+static std::string ToUpper(std::string s)
 {
-    switch (state)
-    {
-    case IPP_PRINTER_IDLE:
-        return "ready";
-    case IPP_PRINTER_PROCESSING:
-        return "printing";
-    case IPP_PRINTER_STOPPED:
-        return "stopped";
-    default:
-        return "unknown";
-    }
+    std::transform(s.begin(), s.end(), s.begin(),
+        [](unsigned char c) { return (char)std::toupper(c); });
+    return s;
 }
 
-PrinterInfo LinuxPrinter::GetPrinterDetails(const std::string &printerName, bool isDefault)
+static std::vector<uint8_t> ReadAllBytes(const std::string &path)
 {
-    PrinterInfo info;
-    info.name = printerName;
-    info.isDefault = isDefault;
+    std::ifstream f(path, std::ios::binary);
+    if (!f) return {};
+
+    f.seekg(0, std::ios::end);
+    std::streamsize size = f.tellg();
+    if (size < 0) return {};
 
-    cups_dest_t *dests;
-    int num_dests = cupsGetDests(&dests);
-    cups_dest_t *dest = cupsGetDest(printerName.c_str(), NULL, num_dests, dests);
+    f.seekg(0, std::ios::beg);
+
+    std::vector<uint8_t> buf((size_t)size);
+    if (size > 0)
+        f.read((char*)buf.data(), size);
+
+    return buf;
+}
+
+/* =========================================================
+   Printer Listing
+========================================================= */
+
+std::vector<PrinterDetailsNative> LinuxPrinter::GetPrinters()
+{
+    std::vector<PrinterDetailsNative> out;
 
-    if (dest != NULL)
+    cups_dest_t *dests = nullptr;
+    int num = cupsGetDests(&dests);
+
+    for (int i = 0; i < num; i++)
     {
-        for (int i = 0; i < dest->num_options; i++)
+        PrinterDetailsNative p;
+        p.name = dests[i].name ? dests[i].name : "";
+        p.isDefault = dests[i].is_default != 0;
+
+        for (int k = 0; k < dests[i].num_options; k++)
         {
-            info.details[dest->options[i].name] = dest->options[i].value;
+            if (dests[i].options[k].name && dests[i].options[k].value)
+                p.options[dests[i].options[k].name] = dests[i].options[k].value;
         }
 
-        http_t *http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC,
-                                    HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL);
-        if (http != NULL)
-        {
-            ipp_t *request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
+        out.push_back(std::move(p));
+    }
 
-            char uri[HTTP_MAX_URI];
-            httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
-                             "localhost", 0, "/printers/%s", printerName.c_str());
+    cupsFreeDests(num, dests);
+    return out;
+}
 
-            ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
-                         "printer-uri", NULL, uri);
+PrinterDetailsNative LinuxPrinter::GetPrinter(const std::string &printerName)
+{
+    auto list = GetPrinters();
+    for (auto &p : list)
+        if (p.name == printerName)
+            return p;
 
-            ipp_t *response = cupsDoRequest(http, request, "/");
-            if (response != NULL)
-            {
-                ipp_attribute_t *attr = ippFindAttribute(response,
-                                                         "printer-state", IPP_TAG_ENUM);
-                if (attr != NULL)
-                {
-                    info.status = GetPrinterStatus((ipp_pstate_t)ippGetInteger(attr, 0));
-                }
-
-                attr = ippFindAttribute(response, "printer-location", IPP_TAG_TEXT);
-                if (attr != NULL)
-                    info.details["location"] = ippGetString(attr, 0, NULL);
-
-                attr = ippFindAttribute(response, "printer-info", IPP_TAG_TEXT);
-                if (attr != NULL)
-                    info.details["comment"] = ippGetString(attr, 0, NULL);
-
-                attr = ippFindAttribute(response, "printer-make-and-model", IPP_TAG_TEXT);
-                if (attr != NULL)
-                    info.details["driver"] = ippGetString(attr, 0, NULL);
-
-                attr = ippFindAttribute(response, "port", IPP_TAG_TEXT);
-                if (attr != NULL)
-                    info.details["port"] = ippGetString(attr, 0, NULL);
-
-                ippDelete(response);
-            }
-            httpClose(http);
-        }
-    }
-    cupsFreeDests(num_dests, dests);
-    return info;
+    PrinterDetailsNative p;
+    p.name = printerName;
+    p.isDefault = false;
+    return p;
 }
 
-std::vector<PrinterInfo> LinuxPrinter::GetPrinters()
+std::string LinuxPrinter::GetDefaultPrinterName()
 {
-    std::vector<PrinterInfo> printers;
-    cups_dest_t *dests;
-    int num_dests = cupsGetDests(&dests);
+    cups_dest_t *dests = nullptr;
+    int num = cupsGetDests(&dests);
+
+    cups_dest_t *def = cupsGetDest(NULL, NULL, num, dests);
 
-    for (int i = 0; i < num_dests; i++)
+    std::string name;
+    if (def && def->name)
+        name = def->name;
+
+    cupsFreeDests(num, dests);
+    return name;
+}
+
+/* =========================================================
+   Driver Options / Paper
+========================================================= */
+
+DriverOptions LinuxPrinter::GetPrinterDriverOptions(const std::string &printerName)
+{
+    DriverOptions out;
+
+    const char *ppdPath = cupsGetPPD(printerName.c_str());
+    if (!ppdPath) return out;
+
+    ppd_file_t *ppd = ppdOpenFile(ppdPath);
+    if (!ppd)
+    {
+        unlink(ppdPath);
+        return out;
+    }
+
+    ppdMarkDefaults(ppd);
+
+    for (ppd_option_t *opt = ppd->options; opt; opt = opt->next)
     {
-        printers.push_back(GetPrinterDetails(dests[i].name, dests[i].is_default));
+        std::map<std::string, bool> choices;
+
+        for (int i = 0; i < opt->num_choices; i++)
+        {
+            bool isDefault =
+                (opt->defchoice &&
+                 strcmp(opt->defchoice, opt->choices[i].choice) == 0);
+
+            choices[opt->choices[i].choice] = isDefault;
+        }
+
+        out[opt->keyword ? opt->keyword : ""] = choices;
     }
 
-    cupsFreeDests(num_dests, dests);
-    return printers;
+    ppdClose(ppd);
+    unlink(ppdPath);
+
+    return out;
 }
 
-PrinterInfo LinuxPrinter::GetSystemDefaultPrinter()
+std::string LinuxPrinter::GetSelectedPaperSize(const std::string &printerName)
 {
-    cups_dest_t *dests;
-    int num_dests = cupsGetDests(&dests);
-    cups_dest_t *dest = cupsGetDest(NULL, NULL, num_dests, dests);
+    std::string paper;
 
-    PrinterInfo printer;
-    if (dest != NULL)
+    const char *ppdPath = cupsGetPPD(printerName.c_str());
+    if (!ppdPath) return paper;
+
+    ppd_file_t *ppd = ppdOpenFile(ppdPath);
+    if (!ppd)
     {
-        printer = GetPrinterDetails(dest->name, true);
+        unlink(ppdPath);
+        return paper;
     }
 
-    cupsFreeDests(num_dests, dests);
-    return printer;
+    ppdMarkDefaults(ppd);
+
+    ppd_option_t *opt = ppdFindOption(ppd, "PageSize");
+    if (!opt)
+        opt = ppdFindOption(ppd, "PageRegion");
+
+    if (opt && opt->defchoice)
+        paper = opt->defchoice;
+
+    ppdClose(ppd);
+    unlink(ppdPath);
+
+    return paper;
 }
 
-bool LinuxPrinter::PrintDirect(const std::string &printerName,
-                               const std::vector<uint8_t> &data,
-                               const std::string &dataType)
+/* =========================================================
+   Capabilities
+========================================================= */
+
+std::vector<std::string> LinuxPrinter::GetSupportedPrintFormats()
+{
+    return { "RAW", "TEXT", "PDF", "JPEG", "POSTSCRIPT", "COMMAND", "AUTO" };
+}
+
+/* =========================================================
+   Printing
+========================================================= */
+
+int LinuxPrinter::PrintDirect(const std::string &printerName,
+                              const std::vector<uint8_t> &data,
+                              const std::string &type,
+                              const StringMap &options)
 {
-    int jobId = cupsCreateJob(CUPS_HTTP_DEFAULT, printerName.c_str(),
-                              "Node.js Print Job", 0, NULL);
+    std::string t = ToUpper(type);
+
+    // For PDF/JPEG/POSTSCRIPT -> use temp file + cupsPrintFile
+    if (t == "PDF" || t == "JPEG" || t == "POSTSCRIPT")
+    {
+        char tmpName[] = "/tmp/esslassi_print_XXXXXX";
+        int fd = mkstemp(tmpName);
+        if (fd < 0)
+            return 0;
+
+        FILE *fp = fdopen(fd, "wb");
+        if (!fp)
+        {
+            close(fd);
+            return 0;
+        }
+
+        fwrite(data.data(), 1, data.size(), fp);
+        fclose(fp);
+
+        cups_option_t *cupOpts = nullptr;
+        int num = 0;
+
+        for (auto &kv : options)
+            num = cupsAddOption(kv.first.c_str(),
+                                kv.second.c_str(),
+                                num,
+                                &cupOpts);
+
+        int jobId = cupsPrintFile(
+            printerName.c_str(),
+            tmpName,
+            "Node Print Job",
+            num,
+            cupOpts);
+
+        if (cupOpts)
+            cupsFreeOptions(num, cupOpts);
+
+        unlink(tmpName);
+
+        return jobId > 0 ? jobId : 0;
+    }
+
+    // RAW / TEXT / COMMAND
+    int jobId = cupsCreateJob(
+        CUPS_HTTP_DEFAULT,
+        printerName.c_str(),
+        "Node Print Job",
+        0,
+        NULL);
 
     if (jobId <= 0)
-        return false;
+        return 0;
 
-    http_status_t status = cupsStartDocument(CUPS_HTTP_DEFAULT, printerName.c_str(),
-                                             jobId, "Node.js Print Job",
-                                             dataType.c_str(), 1);
+    http_status_t st = cupsStartDocument(
+        CUPS_HTTP_DEFAULT,
+        printerName.c_str(),
+        jobId,
+        "Node Print Job",
+        CUPS_FORMAT_RAW,
+        1);
 
-    if (status != HTTP_STATUS_CONTINUE)
+    if (st != HTTP_STATUS_CONTINUE)
     {
         cupsCancelJob(printerName.c_str(), jobId);
-        return false;
+        return 0;
     }
 
-    if (cupsWriteRequestData(CUPS_HTTP_DEFAULT,
-                             reinterpret_cast<const char *>(data.data()),
-                             data.size()) != HTTP_STATUS_CONTINUE)
+    if (cupsWriteRequestData(
+            CUPS_HTTP_DEFAULT,
+            (const char*)data.data(),
+            data.size()) != HTTP_STATUS_CONTINUE)
     {
         cupsCancelJob(printerName.c_str(), jobId);
-        return false;
+        return 0;
     }
 
-    status = static_cast<http_status_t>(cupsFinishDocument(CUPS_HTTP_DEFAULT, printerName.c_str()));
-    return status == HTTP_STATUS_OK;
+    ipp_status_t fin =
+        (ipp_status_t)cupsFinishDocument(
+            CUPS_HTTP_DEFAULT,
+            printerName.c_str());
+
+    if (fin > IPP_STATUS_OK_CONFLICT)
+        return 0;
+
+    return jobId;
+}
+
+int LinuxPrinter::PrintFile(const std::string &printerName,
+                            const std::string &filename)
+{
+    int jobId = cupsPrintFile(
+        printerName.c_str(),
+        filename.c_str(),
+        "Node Print Job",
+        0,
+        NULL);
+
+    return jobId > 0 ? jobId : 0;
 }
 
-PrinterInfo LinuxPrinter::GetStatusPrinter(const std::string &printerName)
+/* =========================================================
+   Job Management
+========================================================= */
+
+JobDetailsNative LinuxPrinter::GetJob(const std::string &printerName, int jobId)
 {
-    cups_dest_t *dests;
-    int num_dests = cupsGetDests(&dests);
+    JobDetailsNative j;
+    j.id = jobId;
+    j.printerName = printerName;
+
+    cups_job_t *jobs = nullptr;
+    int num = cupsGetJobs(&jobs,
+                          printerName.c_str(),
+                          0,
+                          CUPS_WHICHJOBS_ALL);
+
+    for (int i = 0; i < num; i++)
+    {
+        if (jobs[i].id == jobId)
+        {
+            j.name = jobs[i].title ? jobs[i].title : "";
+            j.user = jobs[i].user ? jobs[i].user : "";
+            j.format = jobs[i].format ? jobs[i].format : "";
+            j.priority = jobs[i].priority;
+            j.size = jobs[i].size;
+
+            switch (jobs[i].state)
+            {
+                case IPP_JSTATE_PENDING:    j.status = { "PENDING" }; break;
+                case IPP_JSTATE_HELD:       j.status = { "PAUSED" }; break;
+                case IPP_JSTATE_PROCESSING: j.status = { "PRINTING" }; break;
+                case IPP_JSTATE_STOPPED:    j.status = { "ABORTED" }; break;
+                case IPP_JSTATE_CANCELED:   j.status = { "CANCELLED" }; break;
+                case IPP_JSTATE_ABORTED:    j.status = { "ABORTED" }; break;
+                case IPP_JSTATE_COMPLETED:  j.status = { "PRINTED" }; break;
+                default:                    j.status = { "PENDING" }; break;
+            }
 
-    cups_dest_t *defaultDest = cupsGetDest(NULL, NULL, num_dests, dests);
-    bool isDefault = false;
+            j.creationTime = jobs[i].creation_time;
+            j.processingTime = jobs[i].processing_time;
+            j.completedTime = jobs[i].completed_time;
+            break;
+        }
+    }
+
+    cupsFreeJobs(num, jobs);
+    return j;
+}
+
+void LinuxPrinter::SetJob(const std::string &printerName,
+                          int jobId,
+                          const std::string &command)
+{
+    std::string cmd = ToUpper(command);
 
-    if (defaultDest != NULL)
+    if (cmd == "CANCEL")
     {
-        isDefault = (printerName == defaultDest->name);
+        cupsCancelJob(printerName.c_str(), jobId);
+        return;
     }
 
-    cups_dest_t *dest = cupsGetDest(printerName.c_str(), NULL, num_dests, dests);
-    PrinterInfo printer;
+    if (cmd == "PAUSE" || cmd == "HOLD")
+    {
+        cupsHoldJob(printerName.c_str(), jobId);
+        return;
+    }
 
-    if (dest != NULL)
+    if (cmd == "RESUME" || cmd == "RELEASE")
     {
-        printer = GetPrinterDetails(printerName, isDefault);
+        cupsReleaseJob(printerName.c_str(), jobId);
+        return;
     }
+}
 
-    cupsFreeDests(num_dests, dests);
-    return printer;
+std::vector<std::string> LinuxPrinter::GetSupportedJobCommands()
+{
+    return { "CANCEL", "PAUSE", "RESUME" };
 }

package/src/linux_printer.h

@@ -1,21 +1,31 @@
 #ifndef LINUX_PRINTER_H
 #define LINUX_PRINTER_H
-#include <cups/cups.h>
-#include <cups/ppd.h>
-#include <cstdint>
+
 #include "printer_interface.h"
 
 class LinuxPrinter : public PrinterInterface
 {
-private:
-    std::string GetPrinterStatus(ipp_pstate_t state);
-
 public:
-    virtual PrinterInfo GetPrinterDetails(const std::string &printerName, bool isDefault = false) override;
-    virtual std::vector<PrinterInfo> GetPrinters() override;
-    virtual PrinterInfo GetSystemDefaultPrinter() override;
-    virtual bool PrintDirect(const std::string &printerName, const std::vector<uint8_t> &data, const std::string &dataType) override;
-    virtual PrinterInfo GetStatusPrinter(const std::string &printerName) override;
+    std::vector<PrinterDetailsNative> GetPrinters() override;
+    PrinterDetailsNative GetPrinter(const std::string &printerName) override;
+    std::string GetDefaultPrinterName() override;
+
+    DriverOptions GetPrinterDriverOptions(const std::string &printerName) override;
+    std::string GetSelectedPaperSize(const std::string &printerName) override;
+
+    int PrintDirect(const std::string &printerName,
+                    const std::vector<uint8_t> &data,
+                    const std::string &type,
+                    const StringMap &options) override;
+
+    int PrintFile(const std::string &printerName,
+                  const std::string &filename) override;
+
+    std::vector<std::string> GetSupportedPrintFormats() override;
+
+    JobDetailsNative GetJob(const std::string &printerName, int jobId) override;
+    void SetJob(const std::string &printerName, int jobId, const std::string &command) override;
+    std::vector<std::string> GetSupportedJobCommands() override;
 };
 
 #endif