ffi-cups2 0.4.0

data/lib/ffi-cups/printer.rb

@@ -0,0 +1,342 @@
+module Cups
+  class Printer
+    attr_reader :name, :is_default, :options, :connection
+
+    # @param name [String] printer's name
+    # @param options [Hash] printer's options
+    def initialize(name, is_default=nil, options={}, connection=nil)
+      @name = name
+      @is_default = is_default
+      @options = options
+      @connection = connection
+    end
+
+    # Returns the printer state
+    # @return [Symbol] printer state from options
+    def state
+      case options['printer-state']
+      when '3' then :idle
+      when '4' then :printing
+      when '5' then :stopped
+      else :unknown
+      end
+    end
+
+    # Returns the reason for the printer state
+    # @return [Array] array of reasons in string format
+    def state_reasons
+      options['printer-state-reasons'].split(/,/)
+    end
+
+    # Print a file (pdf, jpg, ps, etc.).
+    #
+    # You can pass in a hash of printing options if you want to override the printer's defaults.
+    #
+    # @return [Cups::Job]  can be used to check on the job status.
+    def print_file(filename, title, options={})
+      raise "File not found: #{filename}" unless File.exist? filename
+
+      http = @connection.nil? ? nil : @connection.httpConnect2
+      with_destination(http) do |dest|
+        p_options = nil
+        num_options = 0
+        unless options.empty?
+          p_options = FFI::MemoryPointer.new :pointer
+          options.each do |k, v|
+            # Do not raise invalid options, since cupsCheckDestSupported states valid PPD options as unsupported.
+            # unless self.class.cupsCheckDestSupported(dest.to_ptr, k, v, http)
+              # raise "Option:#{k} #{v if v} not supported for printer: #{@name}"
+            #end
+            num_options = Cups.cupsAddOption(k, v, num_options, p_options)
+          end
+          p_options = p_options.get_pointer(0)
+        end
+
+        job_id = Cups.cupsPrintFile2(http, @name, filename, title, num_options, p_options)
+
+        if job_id == 0
+          raise Cups.cupsLastErrorString()
+        end
+        #Cups::Job.new(job_id, title, @name)
+        Cups::Job.get_job(job_id, @name, 0, @connection)
+      ensure
+        self.class.cupsFreeOptions(num_options, p_options) if p_options
+      end
+    ensure
+      Cups::Connection.close(http) if http
+    end
+
+    # Print a binary blob of data provided as a String.
+    #
+    # You must also specify the mime type.
+    # Like {print_file}, printing options are optional.
+    #
+    # @return [Cups::Job]  can be used to check on the job status.
+    def print_data(data, mime_type, title, options = {})
+      http = @connection.nil? ? nil : @connection.httpConnect2
+      with_destination(http) do |dest|
+        p_options = nil
+        num_options = 0
+        unless options.empty?
+          p_options = FFI::MemoryPointer.new :pointer
+          options.each do |k, v|
+            num_options = Cups.cupsAddOption(k, v, num_options, p_options)
+          end
+          p_options = p_options.get_pointer(0)
+        end
+
+        job_id = Cups.cupsCreateJob(http, @name, title, num_options, p_options)
+        if job_id == 0
+          raise CupsFFI::cupsLastErrorString()
+        end
+
+        # Copy the data into a char pointer to allow null bytes
+        data_pointer = FFI::MemoryPointer.new(:char, data.bytesize)
+        data_pointer.put_bytes(0, data)
+
+        http_status = Cups.cupsStartDocument(@connection, @name,
+                                                job_id, title, mime_type, 1)
+
+        http_status = Cups.cupsWriteRequestData(@connection, data_pointer, data.bytesize)
+
+        ipp_status = Cups.cupsFinishDocument(@connection, @name)
+
+        data_pointer.free
+
+        raise ipp_status.to_s unless ipp_status == :ipp_ok
+
+        Cups::Job.get_job(job_id, @name, 0, @connection)
+      ensure
+        self.class.cupsFreeOptions(num_options, p_options) if p_options
+      end
+    ensure
+      Cups::Connection.close(http) if http
+    end
+
+    private def with_destination(http, &block)
+      self.class.with_destination(http, @name, &block)
+    end
+
+    def self.with_destination(http, name)
+      # Get all destinations with cupsGetDests2
+      dests = FFI::MemoryPointer.new :pointer
+      num_dests = Cups.cupsGetDests2(http, dests)
+
+      # Get the destination from name with cupsGetDest
+      p_dest = Cups.cupsGetDest(name, nil, num_dests, dests.get_pointer(0))
+      dest = Cups::Struct::Destination.new(p_dest)
+      raise "Destination with name: #{name} not found!" if dest.null?
+      yield dest
+    ensure
+      Cups.cupsFreeDests(num_dests, dests.get_pointer(0))
+    end
+
+    class IppGetResolutionParams < FFI::Struct
+      layout yres: :int, :units => Enum::IPP::Res
+    end
+    private_constant :IppGetResolutionParams
+
+    # Find the supported value(s) for the given option.
+    #
+    # If no option is given then the available options are returned.
+    #
+    # @return [Hash, nil] hash with keys :type and :values or nil when option is not supported
+    def find_dest_supported(option = "job-creation-attributes")
+      http = @connection.nil? ? nil : @connection.httpConnect2
+      with_destination(http) do |dest|
+        attr = self.class.cupsFindDestSupported(dest.to_ptr,
+                            option, http);
+        return nil if attr.null?
+
+        count = IppAttibute.ippGetCount(attr)
+        name = IppAttibute.ippGetName(attr)
+        type = IppAttibute.ippGetValueTag(attr)
+        values = count.times.map do |idx|
+          case type
+          when :ipp_tag_resolution then
+            params = IppGetResolutionParams.new
+            xres = IppAttibute.ippGetResolution(attr, idx, params.to_ptr + params.offset_of(:yres), params.to_ptr + params.offset_of(:units))
+            if xres != 0
+              {xres: xres, yres: params[:yres], units: params[:units]}
+            end
+          when :ipp_tag_range then
+            p_uppervalue = FFI::MemoryPointer.new :int
+            low = IppAttibute.ippGetRange(attr, idx, p_uppervalue)
+            if low != 0
+              {lowervalue: low, uppervalue: p_uppervalue.read_int}
+            end
+          when :ipp_tag_enum then
+            int = IppAttibute.ippGetInteger(attr, idx)
+            name = IppAttibute.ippEnumString(option, int)
+            {int: int, name: name}
+          else
+            IppAttibute.ippGetString(attr, idx, nil) || IppAttibute.ippGetInteger(attr, idx)
+          end
+        end
+        { type: type, values: values, name: name }
+      end
+    end
+
+    # Get all destinations (printer devices)
+    # @param connection [Pointer] http pointer from {Cups::Connection#httpConnect2}
+    def self.get_destinations(connection=nil)
+      pointer = FFI::MemoryPointer.new :pointer
+      dests = cupsGetDests2(pointer, connection)
+      printers = []
+      dests.each do |d|
+        printer = Cups::Printer.new(d[:name].dup, d[:is_default]!=0, printer_options(d), connection)
+        printers.push(printer)
+      end
+      cupsFreeDests(dests.count, pointer)
+      return printers
+    end
+
+    # Get a destination by name
+    # @param name [String] name of the printer
+    # @param connection [Pointer] http pointer from {Cups::Connection#httpConnect2}
+    # @return [Printer] a printer object
+    def self.get_destination(name, connection=nil)
+      http = connection.nil? ? nil : connection.httpConnect2
+      printer = with_destination(http, name) do |dest|
+        Cups::Printer.new(dest[:name].dup, dest[:is_default]!=0, printer_options(dest), connection)
+      end
+      Cups::Connection.close(http) if http
+      return printer
+    end
+
+    # Get all possible options of the PPD file of the printer.
+    #
+    # These options can be passed to {print_file}.
+    # CUPS's PPD functions are deprecated, but many PPD based printers can be controlled only by PPD options, instead of IPP options.
+    #
+    # @return [Array<Hash>]  List of accepted options and their attributes.
+    def ppd_options
+      ppd_path = Cups::Ppd.cupsGetPPD(name)
+      if ppd_path.nil? || ppd_path.empty?
+        raise "Error: Could not retrieve PPD for printer '#{name}'"
+      end
+
+      ppd_ptr = Cups::Ppd.ppdOpenFile(ppd_path)
+      if ppd_ptr.null?
+        raise "Error: Failed to open PPD file at #{ppd_path}"
+      end
+
+      # Let CUPS evaluate current printer system runtime option defaults
+      # Cups::Ppd.cupsMarkOptions(ppd_ptr, 0, nil)
+
+      options = []
+
+      opt_ptr = Cups::Ppd.ppdFirstOption(ppd_ptr)
+
+      while !opt_ptr.null?
+        option = Cups::Struct::PpdOption.new(opt_ptr)
+        choices_array = []
+
+        # Safe pointer stepping through contiguous C memory slots of choice definitions
+        option[:num_choices].times do |c_idx|
+          choice_stride = Cups::Struct::PpdChoice.size
+          choice_element_ptr = option[:choices] + (c_idx * choice_stride)
+          choice = Cups::Struct::PpdChoice.new(choice_element_ptr)
+
+          choices_array << {
+            choice: choice[:choice].to_s,
+            marked: choice[:marked] != 0,
+          }
+        end
+
+        options << {
+          keyword: option[:keyword].to_s,
+          text: option[:text].to_s,
+          choices: choices_array,
+          defchoice: option[:defchoice].to_s,
+          ui: option[:ui],
+          section: option[:section],
+        }
+
+        opt_ptr = Cups::Ppd.ppdNextOption(ppd_ptr)
+      end
+
+      options
+    ensure
+      if ppd_ptr && !ppd_ptr.null?
+        Cups::Ppd.ppdClose(ppd_ptr)
+      end
+      File.delete(ppd_path) if ppd_path && File.exist?(ppd_path)
+    end
+
+    private
+    # Wrapper around {::Cups#cupsGetDests2}
+    # @param connection [Pointer] http pointer from {Cups::Connection#httpConnect2}
+    # @param pointer [Pointer] pointer to the destinations
+    # @return [Hash] hashmap of destination structs
+    def self.cupsGetDests2(pointer, connection=nil)
+      http = connection.nil? ? nil : connection.httpConnect2
+      num_dests = Cups.cupsGetDests2(http, pointer)
+      size = Cups::Struct::Destination.size
+      destinations = []
+      num_dests.times do |i|
+        destination = Cups::Struct::Destination.new(pointer.get_pointer(0) + (size * i))
+        destinations.push(destination)
+      end
+      Cups::Connection.close(http) if http
+      return destinations
+    end
+
+    # Wrapper around {::Cups#cupsCheckDestSupported}
+    # @param dest [Pointer] pointer to the destination
+    # @param option [String]
+    # @param value [String]
+    # @param connection [Pointer] http pointer from {Cups::Connection#httpConnect2}
+    # @return [Boolean] true if supported, false otherwise
+    def self.cupsCheckDestSupported(dest, option, value, connection=nil)
+      info = Cups.cupsCopyDestInfo(connection, dest)
+      i = Cups.cupsCheckDestSupported(connection, dest, info, option, value)
+      return !i.zero?
+    end
+
+    def self.cupsFindDestSupported(dest, option, connection=nil)
+      info = Cups.cupsCopyDestInfo(connection, dest)
+      Cups.cupsFindDestSupported(connection, dest, info, option)
+    end
+
+    # Returns a destination's options
+    # @param dest [Object] {Cups::Struct::Destination} object
+    # @return [Hash] hash of destination' options as {Cups::Struct::Option}
+    def self.cups_options(dest)
+      size = Cups::Struct::Option.size
+      options = []
+
+      dest[:num_options].times do |i|
+        option = Cups::Struct::Option.new(dest[:options] + (size * i))
+        options.push(option)
+      end
+      return options
+    end
+
+    # Returns a destination's options as hash
+    # @param dest [Object] {Cups::Struct::Destination} object
+    # @return [Hash] hash of destination' options
+    def self.printer_options(dest)
+      dest_opts = cups_options(dest)
+      options = {}
+      dest_opts.each do |o|
+        options[o[:name].dup] = o[:value].dup
+      end
+      return options
+    end
+
+    # Wrapper around {::Cups#cupsFreeDests}
+    # @param num_dests [Integer]
+    # @param pointer [Pointer] pointer to the destinations
+    def self.cupsFreeDests(num_dests, pointer)
+      Cups.cupsFreeDests(num_dests, pointer.get_pointer(0))
+    end
+
+    # Wrapper around {::Cups#cupsFreeOptions}
+    # @param num_opts [Integer]
+    # @param pointer [Pointer] pointer to the options
+    def self.cupsFreeOptions(num_opts, pointer)
+      Cups.cupsFreeOptions(num_opts, pointer)
+    end
+  end
+end

data/lib/ffi-cups/struct/destination.rb

@@ -0,0 +1,9 @@
+module Cups::Struct
+  class Destination < FFI::Struct
+    layout  :name,        :string,
+            :instance,    :string,
+            :is_default,  :int,
+            :num_options, :int,
+            :options,     :pointer
+  end
+end

data/lib/ffi-cups/struct/ipp_attribute.rb

@@ -0,0 +1,6 @@
+module Cups::Struct
+  class IppAttribute < FFI::Struct
+    # ipp_attribute_t is an opaque pointer
+    layout  :dummy_dont_use, :char
+  end
+end

data/lib/ffi-cups/struct/job.rb

@@ -0,0 +1,15 @@
+module Cups::Struct
+  class Job < FFI::Struct
+    layout  :id,                :int,
+            :dest,              :string,
+            :title,             :string,
+            :user,              :string,
+            :format,            :string,
+            :state,             Cups::Enum::IPP::JobState,
+            :size,              :int,
+            :priority,          :int,
+            :completed_time,    :long,
+            :creation_time,     :long,
+            :processing_time,   :long
+  end
+end

data/lib/ffi-cups/struct/option.rb

@@ -0,0 +1,5 @@
+module Cups::Struct
+  class Option < FFI::Struct
+    layout  :name, :string, :value, :string
+  end
+end

data/lib/ffi-cups/struct/ppd_choice.rb

@@ -0,0 +1,9 @@
+module Cups::Struct
+  class PpdChoice < FFI::Struct
+    layout :marked, :char,                        # 0 if unselected, 1 if active
+      :choice, [:char, Cups::PPD_MAX_NAME],       # Computer key (e.g., "Letter")
+      :text, [:char, Cups::PPD_MAX_TEXT],         # Human readable text
+      :code, :pointer,                            # Pointer to raw PostScript snippet string
+      :option, :pointer                           # Pointer to parent PpdOption struct
+  end
+end

data/lib/ffi-cups/struct/ppd_file.rb

@@ -0,0 +1,6 @@
+module Cups::Struct
+  class PpdFile < FFI::Struct
+    # we treat ppd_file_t as an opaque pointer
+    layout  :dummy_dont_use, :char
+  end
+end

data/lib/ffi-cups/struct/ppd_option.rb

@@ -0,0 +1,14 @@
+module Cups::Struct
+  class PpdOption < FFI::Struct
+    layout :conflicted, :char,                    # Conflict status code
+      :keyword, [:char, Cups::PPD_MAX_NAME],      # Main option key (e.g., "PageSize")
+      :defchoice, [:char, Cups::PPD_MAX_NAME],    # Default option fallback choice
+      :text, [:char, Cups::PPD_MAX_TEXT],         # Human readable descriptive flag
+      :ui, Cups::Enum::Ppd::Ui,                                  # UI type enum (PickOne, PickMany, etc.)
+      :section, Cups::Enum::Ppd::Section,                             # Order dependency section code
+      :order, :float,                             # Sequence execution priority
+      :num_choices, :int,                         # Choices element scale length
+      :choices, :pointer,                         # Points to sequential array block of PpdChoice
+      :subgroup, :pointer                         # PpdSubgroup relationship tracking link
+  end
+end

data/lib/ffi-cups/version.rb

@@ -0,0 +1,3 @@
+module Cups
+  VERSION = "0.4.0"
+end

data/lib/ffi-cups.rb

@@ -0,0 +1,48 @@
+require 'ffi'
+
+module Cups
+
+  # Custom or default path for libcups.so
+  def self.libcups
+    if ENV['CUPS_LIB']
+      ENV['CUPS_LIB']
+    else
+      FFI::LibraryPath.new('cups', abi_number: 2)
+    end
+  end
+
+end
+
+# Constants
+require 'ffi-cups/constants'
+
+# Enums
+require 'ffi-cups/enum/http/status'
+require 'ffi-cups/enum/http/ppd'
+
+# IPP
+require 'ffi-cups/enum/ipp/status'
+require 'ffi-cups/enum/ipp/job_state'
+require 'ffi-cups/enum/ipp/res'
+require 'ffi-cups/enum/ipp/tag'
+
+# Structs
+require 'ffi-cups/struct/option'
+require 'ffi-cups/struct/destination'
+require 'ffi-cups/struct/job'
+require 'ffi-cups/struct/ipp_attribute'
+require 'ffi-cups/struct/ppd_choice'
+require 'ffi-cups/struct/ppd_file'
+require 'ffi-cups/struct/ppd_option'
+
+# Functions
+require 'ffi-cups/ffi/cups'
+require 'ffi-cups/ffi/http'
+require 'ffi-cups/ffi/array'
+require 'ffi-cups/ffi/ipp_attribute'
+require 'ffi-cups/ffi/ppd'
+
+# wrappers
+require 'ffi-cups/connection'
+require 'ffi-cups/job'
+require 'ffi-cups/printer'

data/lib/ffi-cups2.rb

@@ -0,0 +1 @@
+require_relative 'ffi-cups'

data.tar.gz.sig

@@ -0,0 +1,4 @@
+���K�AD@<jG7�E�W�KD�I	+�EI��_%�C .�4�I6㟠�x��7�D ���4�Ԋ��Il
VC�K1e�L�x�W�=���L�#��pa>�������|��b��y|
+4�
+�ݿփ�9�q"hvD�c�m�j��QJn�W،���ז���&���z��ó<Cr"���hN�kۓn��n=;m�\��@�q�늠��J��
+z�
yˮ��ʧ?������iB��j�b���K�0����(9������(

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: ffi-cups2
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Hugo Marquez
+- Nathan Ehresman
+- Lars Kanis
+bindir: exe
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIEBDCCAmygAwIBAgIBBDANBgkqhkiG9w0BAQsFADAoMSYwJAYDVQQDDB1sYXJz
+  L0RDPWdyZWl6LXJlaW5zZG9yZi9EQz1kZTAeFw0yNjAxMDUxMTE5MzRaFw0yNzAx
+  MDUxMTE5MzRaMCgxJjAkBgNVBAMMHWxhcnMvREM9Z3JlaXotcmVpbnNkb3JmL0RD
+  PWRlMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAwum6Y1KznfpzXOT/
+  mZgJTBbxZuuZF49Fq3K0WA67YBzNlDv95qzSp7V/7Ek3NCcnT7G+2kSuhNo1FhdN
+  eSDO/moYebZNAcu3iqLsuzuULXPLuoU0GsMnVMqV9DZPh7cQHE5EBZ7hlzDBK7k/
+  8nBMvR0mHo77kIkapHc26UzVq/G0nKLfDsIHXVylto3PjzOumjG6GhmFN4r3cP6e
+  SDfl1FSeRYVpt4kmQULz/zdSaOH3AjAq7PM2Z91iGwQvoUXMANH2v89OWjQO/NHe
+  JMNDFsmHK/6Ji4Kk48Z3TyscHQnipAID5GhS1oD21/WePdj7GhmbF5gBzkV5uepd
+  eJQPgWGwrQW/Z2oPjRuJrRofzWfrMWqbOahj9uth6WSxhNexUtbjk6P8emmXOJi5
+  chQPnWX+N3Gj+jjYxqTFdwT7Mj3pv1VHa+aNUbqSPpvJeDyxRIuo9hvzDaBHb/Cg
+  9qRVcm8a96n4t7y2lrX1oookY6bkBaxWOMtWlqIprq8JZXM9AgMBAAGjOTA3MAkG
+  A1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQ4h1tIyvdUWtMI739xMzTR
+  7EfMFzANBgkqhkiG9w0BAQsFAAOCAYEAg/1LuXN3X8xwHVnhRvmBCZYkNErko40y
+  juq/qPF9vkPGxLEGaeZF1rv/obTs5SgIGEUkWdRsOl3F6bQN4MYUFlN/n6rPx19g
+  CqUMkmRtuFD+9EFBI4twoF2IJS0pYr9tkjUq8mb0VXblvfbEEUf460BJmuBXZTc6
+  OoLQHxjhhqhKBoP4lHXg/OMK9dnGn8+5DoKcsyWQvqq/GdK8pi4E47M/egzw54Go
+  g+oeyGDsNKOQlnIA9gbyPpExD1+akJ4v88T8jOUnsOkhBBUkpSktC2QmEYIU5e9j
+  N7muw6O5Bz3CQuSWIEjj9mMUS2fEEfq2km6zO5vs5eD6TdFnt8AC/HlOrPaxGcUX
+  Hjw/K7ZTvZLEb4awRijdy4wx3OlL9FAyZPjYOh8TdJrLl076c7GyimAkgnc8BrL5
+  g1vGc759o2t3KNnlUg8VwqkhFJp4gCko1QO/8Io5hPQZOvJw8dmqNiiiHqaDupfl
+  CI4mk2K8yQa8xtQ/RmFZxYS5XbHhDJCw
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+description: Simple wrapper around libcups to give CUPS printing capabilities to Ruby
+  apps.
+email:
+- hugomarquez.dev@gmail.com
+- n_github@ehresman.org
+- lars@greiz-reinsdorf.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ffi-cups.gemspec
+- lib/ffi-cups.rb
+- lib/ffi-cups/connection.rb
+- lib/ffi-cups/constants.rb
+- lib/ffi-cups/enum/http/ppd.rb
+- lib/ffi-cups/enum/http/status.rb
+- lib/ffi-cups/enum/ipp/job_state.rb
+- lib/ffi-cups/enum/ipp/res.rb
+- lib/ffi-cups/enum/ipp/status.rb
+- lib/ffi-cups/enum/ipp/tag.rb
+- lib/ffi-cups/ffi/array.rb
+- lib/ffi-cups/ffi/cups.rb
+- lib/ffi-cups/ffi/http.rb
+- lib/ffi-cups/ffi/ipp_attribute.rb
+- lib/ffi-cups/ffi/ppd.rb
+- lib/ffi-cups/job.rb
+- lib/ffi-cups/printer.rb
+- lib/ffi-cups/struct/destination.rb
+- lib/ffi-cups/struct/ipp_attribute.rb
+- lib/ffi-cups/struct/job.rb
+- lib/ffi-cups/struct/option.rb
+- lib/ffi-cups/struct/ppd_choice.rb
+- lib/ffi-cups/struct/ppd_file.rb
+- lib/ffi-cups/struct/ppd_option.rb
+- lib/ffi-cups/version.rb
+- lib/ffi-cups2.rb
+homepage: https://github.com/larskanis/ffi-cups
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: FFI wrapper around libcups2
+test_files: []