@luckykiet/node-printer 1.0.0

package/src/node_printer.hpp

@@ -0,0 +1,123 @@
+#ifndef NODE_PRINTER_HPP
+#define NODE_PRINTER_HPP
+
+#include "macros.hh"
+
+#include <node.h>
+#include <v8.h>
+
+#include <string>
+
+/**
+ * Send data to printer
+ *
+ * @param data String/NativeBuffer, mandatory, raw data bytes
+ * @param printername String, mandatory, specifying printer name
+ * @param docname String, mandatory, specifying document name
+ * @param type String, mandatory, specifying data type. E.G.: RAW, TEXT, ...
+ *
+ * @returns true for success, false for failure.
+ */
+MY_NODE_MODULE_CALLBACK(PrintDirect);
+
+/**
+ * Send file to printer
+ *
+ * @param filename String, mandatory, specifying filename to print
+ * @param docname String, mandatory, specifying document name
+ * @param printer String, mandatory, specifying printer name
+ *
+ * @returns jobId for success, or error message for failure.
+ */
+MY_NODE_MODULE_CALLBACK(PrintFile);
+
+/** Retrieve all printers and jobs
+ * posix: minimum version: CUPS 1.1.21/OS X 10.4
+ */
+MY_NODE_MODULE_CALLBACK(getPrinters);
+
+/**
+ * Return default printer name, if null then default printer is not set
+ */
+MY_NODE_MODULE_CALLBACK(getDefaultPrinterName);
+
+/** Retrieve printer info and jobs
+ * @param printer name String
+ */
+MY_NODE_MODULE_CALLBACK(getPrinter);
+
+/** Retrieve printer driver info
+ * @param printer name String
+ */
+MY_NODE_MODULE_CALLBACK(getPrinterDriverOptions);
+
+/** Retrieve job info
+ *  @param printer name String
+ *  @param job id Number
+ */
+MY_NODE_MODULE_CALLBACK(getJob);
+
+//TODO
+/** Set job command. 
+ * arguments:
+ * @param printer name String
+ * @param job id Number
+ * @param job command String
+ * Possible commands:
+ *      "CANCEL"
+ *      "PAUSE"
+ *      "RESTART"
+ *      "RESUME"
+ *      "DELETE"
+ *      "SENT-TO-PRINTER"
+ *      "LAST-PAGE-EJECTED"
+ *      "RETAIN"
+ *      "RELEASE"
+ */
+MY_NODE_MODULE_CALLBACK(setJob);
+
+/** Get supported print formats for printDirect. It depends on platform
+ */
+MY_NODE_MODULE_CALLBACK(getSupportedPrintFormats);
+
+/** Get supported job commands for setJob method
+ */
+MY_NODE_MODULE_CALLBACK(getSupportedJobCommands);
+
+//TODO:
+// optional ability to get printer spool
+
+
+// util class
+
+/** Memory value class management to avoid memory leak
+ * TODO: move to std::unique_ptr on switching to C++11
+*/
+template<typename Type>
+class MemValueBase
+{
+public:
+    MemValueBase(): _value(NULL) {}
+
+    /** Destructor. The allocated memory will be deallocated
+    */
+    virtual ~MemValueBase() {}
+
+    Type * get() {return _value; }
+    Type * operator ->() { return &_value; }
+    operator bool() const { return (_value != NULL); }
+protected:
+    Type *_value;
+
+    virtual void free() {};
+};
+
+/**
+ * try to extract String or buffer from v8 value
+ * @param iV8Value - source v8 value
+ * @param oData - destination data
+ * @return TRUE if value is String or Buffer, FALSE otherwise
+ */
+bool getStringOrBufferFromV8Value(v8::Local<v8::Value> iV8Value, std::string &oData);
+
+#endif

package/src/node_printer_posix.cc

@@ -0,0 +1,530 @@
+#include "node_printer.hpp"
+
+#include <string>
+#include <map>
+#include <utility>
+#include <sstream>
+#include <node_version.h>
+
+#include <cups/cups.h>
+#include <cups/ppd.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+namespace
+{
+    typedef std::map<std::string, int> StatusMapType;
+    typedef std::map<std::string, std::string> FormatMapType;
+
+    const StatusMapType& getJobStatusMap()
+    {
+        static StatusMapType result;
+        if(!result.empty())
+        {
+            return result;
+        }
+        // add only first time
+#define STATUS_PRINTER_ADD(value, type) result.insert(std::make_pair(value, type))
+        // Common statuses
+        STATUS_PRINTER_ADD("PRINTING", IPP_JOB_PROCESSING);
+        STATUS_PRINTER_ADD("PRINTED", IPP_JOB_COMPLETED);
+        STATUS_PRINTER_ADD("PAUSED", IPP_JOB_HELD);
+        // Specific statuses
+        STATUS_PRINTER_ADD("PENDING", IPP_JOB_PENDING);
+        STATUS_PRINTER_ADD("PAUSED", IPP_JOB_STOPPED);
+        STATUS_PRINTER_ADD("CANCELLED", IPP_JOB_CANCELLED);
+        STATUS_PRINTER_ADD("ABORTED", IPP_JOB_ABORTED);
+
+#undef STATUS_PRINTER_ADD
+        return result;
+    }
+
+    const FormatMapType& getPrinterFormatMap()
+    {
+        static FormatMapType result;
+        if(!result.empty())
+        {
+            return result;
+        }
+        result.insert(std::make_pair("RAW", CUPS_FORMAT_RAW));
+        result.insert(std::make_pair("TEXT", CUPS_FORMAT_TEXT));
+#ifdef CUPS_FORMAT_PDF
+        result.insert(std::make_pair("PDF", CUPS_FORMAT_PDF));
+#endif
+#ifdef CUPS_FORMAT_JPEG
+        result.insert(std::make_pair("JPEG", CUPS_FORMAT_JPEG));
+#endif
+#ifdef CUPS_FORMAT_POSTSCRIPT
+        result.insert(std::make_pair("POSTSCRIPT", CUPS_FORMAT_POSTSCRIPT));
+#endif
+#ifdef CUPS_FORMAT_COMMAND
+        result.insert(std::make_pair("COMMAND", CUPS_FORMAT_COMMAND));
+#endif
+#ifdef CUPS_FORMAT_AUTO
+        result.insert(std::make_pair("AUTO", CUPS_FORMAT_AUTO));
+#endif
+        return result;
+    }
+
+    /** Parse job info object.
+     * @return error string. if empty, then no error
+     */
+    std::string parseJobObject(const cups_job_t *job, v8::Local<v8::Object> result_printer_job)
+    {
+        MY_NODE_MODULE_ISOLATE_DECL
+        //Common fields
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("id"), V8_VALUE_NEW(Number, job->id));
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("name"), V8_STRING_NEW_UTF8(job->title));
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("printerName"), V8_STRING_NEW_UTF8(job->dest));
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("user"), V8_STRING_NEW_UTF8(job->user));
+        std::string job_format(job->format);
+
+        // Try to parse the data format, otherwise will write the unformatted one
+        for(FormatMapType::const_iterator itFormat = getPrinterFormatMap().begin(); itFormat != getPrinterFormatMap().end(); ++itFormat)
+        {
+            if(itFormat->second == job_format)
+            {
+                job_format = itFormat->first;
+                break;
+            }
+        }
+
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("format"), V8_STRING_NEW_UTF8(job_format.c_str()));
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("priority"), V8_VALUE_NEW(Number, job->priority));
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("size"), V8_VALUE_NEW(Number, job->size));
+        v8::Local<v8::Array> result_printer_job_status = V8_VALUE_NEW_DEFAULT(Array);
+        int i_status = 0;
+        for(StatusMapType::const_iterator itStatus = getJobStatusMap().begin(); itStatus != getJobStatusMap().end(); ++itStatus)
+        {
+            if(job->state == itStatus->second)
+            {
+                Nan::Set(result_printer_job_status, i_status++, V8_STRING_NEW_UTF8(itStatus->first.c_str()));
+                // only one status could be on posix
+                break;
+            }
+        }
+        if(i_status == 0)
+        {
+            // A new status? report as unsupported
+            std::ostringstream s;
+            s << "unsupported job status: " << job->state;
+            Nan::Set(result_printer_job_status, i_status++, V8_STRING_NEW_UTF8(s.str().c_str()));
+        }
+
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("status"), result_printer_job_status);
+
+        //Specific fields
+        // Ecmascript store time in milliseconds, but time_t in seconds
+
+        double creationTime = ((double)job->creation_time) * 1000;
+        double completedTime = ((double)job->completed_time) * 1000;
+        double processingTime = ((double)job->processing_time) * 1000;
+
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("completedTime"), Nan::New<v8::Date>(completedTime).ToLocalChecked());
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("creationTime"), Nan::New<v8::Date>(creationTime).ToLocalChecked());
+        Nan::Set(result_printer_job, V8_STRING_NEW_UTF8("processingTime"), Nan::New<v8::Date>(processingTime).ToLocalChecked());
+
+        // No error. return an empty string
+        return "";
+    }
+
+    /** Parses printer driver PPD options
+     */
+    void populatePpdOptions(v8::Local<v8::Object> ppd_options, ppd_file_t  *ppd, ppd_group_t *group)
+    {
+        int i, j;
+        ppd_option_t *option;
+        ppd_choice_t *choice;
+        ppd_group_t *subgroup;
+
+        for (i = group->num_options, option = group->options; i > 0; --i, ++option)
+        {
+            MY_NODE_MODULE_ISOLATE_DECL
+            v8::Local<v8::Object> ppd_suboptions = V8_VALUE_NEW_DEFAULT(Object);
+            for (j = option->num_choices, choice = option->choices;
+                 j > 0;
+                 --j, ++choice)
+            {
+                Nan::Set(ppd_suboptions, V8_STRING_NEW_UTF8(choice->choice), V8_VALUE_NEW(Boolean, static_cast<bool>(choice->marked)));
+            }
+
+            Nan::Set(ppd_options, V8_STRING_NEW_UTF8(option->keyword), ppd_suboptions);
+        }
+
+        for (i = group->num_subgroups, subgroup = group->subgroups; i > 0; --i, ++subgroup) {
+            populatePpdOptions(ppd_options, ppd, subgroup);
+        }
+    }
+
+    /** Parse printer driver options
+     * @return error string.
+     */
+    std::string parseDriverOptions(const cups_dest_t * printer, v8::Local<v8::Object> ppd_options)
+    {
+        const char *filename;
+        ppd_file_t *ppd;
+        ppd_group_t *group;
+        int i;
+
+        std::ostringstream error_str; // error string
+
+        if ((filename = cupsGetPPD(printer->name)) != NULL)
+        {
+            if ((ppd = ppdOpenFile(filename)) != NULL)
+            {
+                 ppdMarkDefaults(ppd);
+                 cupsMarkOptions(ppd, printer->num_options, printer->options);
+
+                 for (i = ppd->num_groups, group = ppd->groups; i > 0; --i, ++group)
+                 {
+                    populatePpdOptions(ppd_options, ppd, group);
+                 }
+                 ppdClose(ppd);
+            }
+            else
+            {
+                error_str << "Unable to open PPD filename " << filename << " ";
+            }
+            unlink(filename);
+        }
+        else
+        {
+            error_str << "Unable to get CUPS PPD driver file. ";
+        }
+
+        return error_str.str();
+    }
+
+
+    /** Parse printer info object
+     * @return error string.
+     */
+    std::string parsePrinterInfo(const cups_dest_t * printer, v8::Local<v8::Object> result_printer)
+    {
+        MY_NODE_MODULE_ISOLATE_DECL
+        Nan::Set(result_printer, V8_STRING_NEW_UTF8("name"), V8_STRING_NEW_UTF8(printer->name));
+        Nan::Set(result_printer, V8_STRING_NEW_UTF8("isDefault"), V8_VALUE_NEW(Boolean, static_cast<bool>(printer->is_default)));
+
+        if(printer->instance)
+        {
+            Nan::Set(result_printer, V8_STRING_NEW_UTF8("instance"), V8_STRING_NEW_UTF8(printer->instance));
+        }
+
+        v8::Local<v8::Object> result_printer_options = V8_VALUE_NEW_DEFAULT(Object);
+        cups_option_t *dest_option = printer->options;
+        for(int j = 0; j < printer->num_options; ++j, ++dest_option)
+        {
+            Nan::Set(result_printer_options, V8_STRING_NEW_UTF8(dest_option->name), V8_STRING_NEW_UTF8(dest_option->value));
+        }
+        Nan::Set(result_printer, V8_STRING_NEW_UTF8("options"), result_printer_options);
+        // Get printer jobs
+        cups_job_t * jobs;
+        int totalJobs = cupsGetJobs(&jobs, printer->name, 0 /*0 means all users*/, CUPS_WHICHJOBS_ACTIVE);
+        std::string error_str;
+        if(totalJobs > 0)
+        {
+            v8::Local<v8::Array> result_priner_jobs = V8_VALUE_NEW(Array, totalJobs);
+            int jobi =0;
+            cups_job_t * job = jobs;
+            for(; jobi < totalJobs; ++jobi, ++job)
+            {
+                v8::Local<v8::Object> result_printer_job = V8_VALUE_NEW_DEFAULT(Object);
+                error_str = parseJobObject(job, result_printer_job);
+                if(!error_str.empty())
+                {
+                    // got an error? break then.
+                    break;
+                }
+                Nan::Set(result_priner_jobs, jobi, result_printer_job);
+            }
+            Nan::Set(result_printer, V8_STRING_NEW_UTF8("jobs"), result_priner_jobs);
+        }
+        cupsFreeJobs(totalJobs, jobs);
+        return error_str;
+    }
+
+    /// cups option class to automatically free memory.
+    class CupsOptions: public MemValueBase<cups_option_t> {
+    protected:
+        int num_options;
+        virtual void free() {
+            if(_value != NULL)
+            {
+                cupsFreeOptions(num_options, get());
+                _value = NULL;
+                num_options = 0;
+            }
+        }
+    public:
+        CupsOptions(): num_options(0) {}
+        ~CupsOptions () { free(); }
+
+        /// Add options from v8 object
+        CupsOptions(v8::Local<v8::Object> iV8Options): num_options(0) {
+            v8::Local<v8::Array> props = Nan::GetPropertyNames(iV8Options).ToLocalChecked();
+
+            for(unsigned int i = 0; i < props->Length(); ++i) {
+                v8::Local<v8::Value> key(Nan::Get(props, i).ToLocalChecked());
+                Nan::Utf8String keyStr(V8_LOCAL_STRING_FROM_VALUE(key));
+                Nan::Utf8String valStr(V8_LOCAL_STRING_FROM_VALUE(Nan::Get(iV8Options, key).ToLocalChecked()));
+
+                num_options = cupsAddOption(*keyStr, *valStr, num_options, &_value);
+            }
+        }
+
+        const int& getNumOptions() { return num_options; }
+    };
+}
+
+MY_NODE_MODULE_CALLBACK(getPrinters)
+{
+    MY_NODE_MODULE_HANDLESCOPE;
+
+    cups_dest_t *printers = NULL;
+    int printers_size = cupsGetDests(&printers);
+    v8::Local<v8::Array> result = V8_VALUE_NEW(Array, printers_size);
+    cups_dest_t *printer = printers;
+    std::string error_str;
+    for(int i = 0; i < printers_size; ++i, ++printer)
+    {
+        v8::Local<v8::Object> result_printer = V8_VALUE_NEW_DEFAULT(Object);
+        error_str = parsePrinterInfo(printer, result_printer);
+        if(!error_str.empty())
+        {
+            // got an error? break then
+            break;
+        }
+        Nan::Set(result, i, result_printer);
+    }
+    cupsFreeDests(printers_size, printers);
+    if(!error_str.empty())
+    {
+        // got an error? return the error then
+        RETURN_EXCEPTION_STR(error_str.c_str());
+    }
+    MY_NODE_MODULE_RETURN_VALUE(result);
+}
+
+MY_NODE_MODULE_CALLBACK(getDefaultPrinterName)
+{
+    MY_NODE_MODULE_HANDLESCOPE;
+    //This does not return default user printer name according to https://www.cups.org/documentation.php/doc-2.0/api-cups.html#cupsGetDefault2
+    //so leave as undefined and JS implementation will loop in all printers
+    /*
+    const char * printerName = cupsGetDefault();
+
+    // return default printer name only if defined
+    if(printerName != NULL) {
+        MY_NODE_MODULE_RETURN_VALUE(V8_STRING_NEW_UTF8(printerName));
+    }
+    */
+    MY_NODE_MODULE_RETURN_UNDEFINED();
+}
+
+MY_NODE_MODULE_CALLBACK(getPrinter)
+{
+    MY_NODE_MODULE_HANDLESCOPE;
+    REQUIRE_ARGUMENTS(iArgs, 1);
+    REQUIRE_ARGUMENT_STRING(iArgs, 0, printername);
+
+    cups_dest_t *printers = NULL, *printer = NULL;
+    int printers_size = cupsGetDests(&printers);
+    printer = cupsGetDest(*printername, NULL, printers_size, printers);
+    v8::Local<v8::Object> result_printer = V8_VALUE_NEW_DEFAULT(Object);
+    if(printer != NULL)
+    {
+        parsePrinterInfo(printer, result_printer);
+    }
+    cupsFreeDests(printers_size, printers);
+    if(printer == NULL)
+    {
+        // printer not found
+        RETURN_EXCEPTION_STR("Printer not found");
+    }
+    MY_NODE_MODULE_RETURN_VALUE(result_printer);
+}
+
+MY_NODE_MODULE_CALLBACK(getPrinterDriverOptions)
+{
+    MY_NODE_MODULE_HANDLESCOPE;
+    REQUIRE_ARGUMENTS(iArgs, 1);
+    REQUIRE_ARGUMENT_STRING(iArgs, 0, printername);
+
+    cups_dest_t *printers = NULL, *printer = NULL;
+    int printers_size = cupsGetDests(&printers);
+    printer = cupsGetDest(*printername, NULL, printers_size, printers);
+    v8::Local<v8::Object> driver_options = V8_VALUE_NEW_DEFAULT(Object);
+    if(printer != NULL)
+    {
+        parseDriverOptions(printer, driver_options);
+    }
+    cupsFreeDests(printers_size, printers);
+    if(printer == NULL)
+    {
+        // printer not found
+        RETURN_EXCEPTION_STR("Printer not found");
+    }
+    MY_NODE_MODULE_RETURN_VALUE(driver_options);
+}
+
+MY_NODE_MODULE_CALLBACK(getJob)
+{
+    MY_NODE_MODULE_HANDLESCOPE;
+    REQUIRE_ARGUMENTS(iArgs, 2);
+    REQUIRE_ARGUMENT_STRING(iArgs, 0, printername);
+    REQUIRE_ARGUMENT_INTEGER(iArgs, 1, jobId);
+
+    v8::Local<v8::Object> result_printer_job = V8_VALUE_NEW_DEFAULT(Object);
+    // Get printer jobs
+    cups_job_t *jobs = NULL, *jobFound = NULL;
+    int totalJobs = cupsGetJobs(&jobs, *printername, 0 /*0 means all users*/, CUPS_WHICHJOBS_ALL);
+    if(totalJobs > 0)
+    {
+        int jobi =0;
+        cups_job_t * job = jobs;
+        for(; jobi < totalJobs; ++jobi, ++job)
+        {
+            if(job->id != jobId)
+            {
+                continue;
+            }
+            // Job Found
+            jobFound = job;
+            parseJobObject(job, result_printer_job);
+            break;
+        }
+    }
+    cupsFreeJobs(totalJobs, jobs);
+    if(jobFound == NULL)
+    {
+        // printer not found
+        RETURN_EXCEPTION_STR("Printer job not found");
+    }
+    MY_NODE_MODULE_RETURN_VALUE(result_printer_job);
+}
+
+MY_NODE_MODULE_CALLBACK(setJob)
+{
+    MY_NODE_MODULE_HANDLESCOPE;
+    REQUIRE_ARGUMENTS(iArgs, 3);
+    REQUIRE_ARGUMENT_STRING(iArgs, 0, printername);
+    REQUIRE_ARGUMENT_INTEGER(iArgs, 1, jobId);
+    REQUIRE_ARGUMENT_STRING(iArgs, 2, jobCommandV8);
+    if(jobId < 0)
+    {
+        RETURN_EXCEPTION_STR("Wrong job number");
+    }
+    std::string jobCommandStr(*jobCommandV8);
+    bool result_ok = false;
+    if(jobCommandStr == "CANCEL")
+    {
+        result_ok = (cupsCancelJob(*printername, jobId) == 1);
+    }
+    else
+    {
+        RETURN_EXCEPTION_STR("wrong job command. use getSupportedJobCommands to see the possible commands");
+    }
+    MY_NODE_MODULE_RETURN_VALUE(V8_VALUE_NEW(Boolean, result_ok));
+}
+
+MY_NODE_MODULE_CALLBACK(getSupportedJobCommands)
+{
+    MY_NODE_MODULE_HANDLESCOPE;
+    v8::Local<v8::Array> result = V8_VALUE_NEW_DEFAULT(Array);
+    int i = 0;
+    Nan::Set(result, i++, V8_STRING_NEW_UTF8("CANCEL"));
+    MY_NODE_MODULE_RETURN_VALUE(result);
+}
+
+MY_NODE_MODULE_CALLBACK(getSupportedPrintFormats)
+{
+    MY_NODE_MODULE_HANDLESCOPE;
+    v8::Local<v8::Array> result = V8_VALUE_NEW_DEFAULT(Array);
+    int i = 0;
+    for(FormatMapType::const_iterator itFormat = getPrinterFormatMap().begin(); itFormat != getPrinterFormatMap().end(); ++itFormat)
+    {
+        Nan::Set(result, i++, V8_STRING_NEW_UTF8(itFormat->first.c_str()));
+    }
+    MY_NODE_MODULE_RETURN_VALUE(result);
+}
+
+MY_NODE_MODULE_CALLBACK(PrintDirect)
+{
+    MY_NODE_MODULE_HANDLESCOPE;
+    REQUIRE_ARGUMENTS(iArgs, 5);
+
+    // can be string or buffer
+    if(iArgs.Length() <= 0)
+    {
+        RETURN_EXCEPTION_STR("Argument 0 missing");
+    }
+
+    std::string data;
+    v8::Local<v8::Value> arg0(iArgs[0]);
+    if (!getStringOrBufferFromV8Value(arg0, data))
+    {
+        RETURN_EXCEPTION_STR("Argument 0 must be a string or Buffer");
+    }
+
+    REQUIRE_ARGUMENT_STRING(iArgs, 1, printername);
+    REQUIRE_ARGUMENT_STRING(iArgs, 2, docname);
+    REQUIRE_ARGUMENT_STRING(iArgs, 3, type);
+    REQUIRE_ARGUMENT_OBJECT(iArgs, 4, print_options);
+
+    std::string type_str(*type);
+    FormatMapType::const_iterator itFormat = getPrinterFormatMap().find(type_str);
+    if(itFormat == getPrinterFormatMap().end())
+    {
+        RETURN_EXCEPTION_STR("unsupported format type");
+    }
+    type_str = itFormat->second;
+
+    CupsOptions options(print_options);
+
+    int job_id = cupsCreateJob(CUPS_HTTP_DEFAULT, *printername, *docname, options.getNumOptions(), options.get());
+    if(job_id == 0) {
+        RETURN_EXCEPTION_STR(cupsLastErrorString());
+    }
+
+    if(HTTP_CONTINUE != cupsStartDocument(CUPS_HTTP_DEFAULT, *printername, job_id, *docname, type_str.c_str(), 1 /*last document*/)) {
+        RETURN_EXCEPTION_STR(cupsLastErrorString());
+    }
+
+    /* cupsWriteRequestData can be called as many times as needed */
+    //TODO: to split big buffer
+    if (HTTP_CONTINUE != cupsWriteRequestData(CUPS_HTTP_DEFAULT, data.c_str(), data.size())) {
+        cupsFinishDocument(CUPS_HTTP_DEFAULT, *printername);
+        RETURN_EXCEPTION_STR(cupsLastErrorString());
+    }
+
+    cupsFinishDocument(CUPS_HTTP_DEFAULT, *printername);
+
+    MY_NODE_MODULE_RETURN_VALUE(V8_VALUE_NEW(Number, job_id));
+}
+
+MY_NODE_MODULE_CALLBACK(PrintFile)
+{
+    MY_NODE_MODULE_HANDLESCOPE;
+    REQUIRE_ARGUMENTS(iArgs, 3);
+
+    // can be string or buffer
+    if(iArgs.Length() <= 0)
+    {
+        RETURN_EXCEPTION_STR("Argument 0 missing");
+    }
+
+    REQUIRE_ARGUMENT_STRING(iArgs, 0, filename);
+    REQUIRE_ARGUMENT_STRING(iArgs, 1, docname);
+    REQUIRE_ARGUMENT_STRING(iArgs, 2, printer);
+    REQUIRE_ARGUMENT_OBJECT(iArgs, 3, print_options);
+
+    CupsOptions options(print_options);
+
+    int job_id = cupsPrintFile(*printer, *filename, *docname, options.getNumOptions(), options.get());
+
+    if(job_id == 0){
+        MY_NODE_MODULE_RETURN_VALUE(V8_STRING_NEW_UTF8(cupsLastErrorString()));
+    } else {
+        MY_NODE_MODULE_RETURN_VALUE(V8_VALUE_NEW(Number, job_id));
+    }
+}