Pileus Git - ~andy/gtk/blob - modules/printbackends/cups/gtkcupsutils.h

   1 /* gtkcupsutils.h
   2  * Copyright (C) 2006 John (J5) Palmieri <johnp@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifndef __GTK_CUPS_UTILS_H__
  21 #define __GTK_CUPS_UTILS_H__
  22
  23 #include <glib.h>
  24 #include <cups/cups.h>
  25 #include <cups/language.h>
  26 #include <cups/http.h>
  27 #include <cups/ipp.h>
  28
  29 G_BEGIN_DECLS
  30
  31 typedef struct _GtkCupsRequest        GtkCupsRequest;
  32 typedef struct _GtkCupsResult         GtkCupsResult;
  33 typedef struct _GtkCupsConnectionTest GtkCupsConnectionTest;
  34
  35 typedef enum
  36 {
  37   GTK_CUPS_ERROR_HTTP,
  38   GTK_CUPS_ERROR_IPP,
  39   GTK_CUPS_ERROR_IO,
  40   GTK_CUPS_ERROR_AUTH,
  41   GTK_CUPS_ERROR_GENERAL
  42 } GtkCupsErrorType;
  43
  44 typedef enum
  45 {
  46   GTK_CUPS_POST,
  47   GTK_CUPS_GET
  48 } GtkCupsRequestType;
  49
  50
  51 /**
  52  * Direction we should be polling the http socket on.
  53  * We are either reading or writting at each state.
  54  * This makes it easy for mainloops to connect to poll.
  55  */
  56 typedef enum
  57 {
  58   GTK_CUPS_HTTP_IDLE,
  59   GTK_CUPS_HTTP_READ,
  60   GTK_CUPS_HTTP_WRITE
  61 } GtkCupsPollState;
  62
  63 typedef enum
  64 {
  65   GTK_CUPS_CONNECTION_AVAILABLE,
  66   GTK_CUPS_CONNECTION_NOT_AVAILABLE,
  67   GTK_CUPS_CONNECTION_IN_PROGRESS
  68 } GtkCupsConnectionState;
  69
  70 typedef enum
  71 {
  72   GTK_CUPS_PASSWORD_NONE,
  73   GTK_CUPS_PASSWORD_REQUESTED,
  74   GTK_CUPS_PASSWORD_HAS,
  75   GTK_CUPS_PASSWORD_APPLIED,
  76   GTK_CUPS_PASSWORD_NOT_VALID
  77 } GtkCupsPasswordState;
  78
  79 struct _GtkCupsRequest
  80 {
  81   GtkCupsRequestType type;
  82
  83   http_t *http;
  84   http_status_t last_status;
  85   ipp_t *ipp_request;
  86
  87   gchar *server;
  88   gchar *resource;
  89   GIOChannel *data_io;
  90   gint attempts;
  91
  92   GtkCupsResult *result;
  93
  94   gint state;
  95   GtkCupsPollState poll_state;
  96
  97   gchar *password;
  98   gchar *username;
  99
 100   gint own_http : 1;
 101   gint need_password : 1;
 102   gint need_auth_info : 1;
 103   gchar **auth_info_required;
 104   gchar **auth_info;
 105   GtkCupsPasswordState password_state;
 106 };
 107
 108 struct _GtkCupsConnectionTest
 109 {
 110 #ifdef HAVE_CUPS_API_1_2
 111   GtkCupsConnectionState at_init;
 112   http_addrlist_t       *addrlist;
 113   http_addrlist_t       *current_addr;
 114   http_addrlist_t       *last_wrong_addr;
 115   gint                   socket;
 116 #endif
 117 };
 118
 119 #define GTK_CUPS_REQUEST_START 0
 120 #define GTK_CUPS_REQUEST_DONE 500
 121
 122 /* POST states */
 123 enum
 124 {
 125   GTK_CUPS_POST_CONNECT = GTK_CUPS_REQUEST_START,
 126   GTK_CUPS_POST_SEND,
 127   GTK_CUPS_POST_WRITE_REQUEST,
 128   GTK_CUPS_POST_WRITE_DATA,
 129   GTK_CUPS_POST_CHECK,
 130   GTK_CUPS_POST_AUTH,
 131   GTK_CUPS_POST_READ_RESPONSE,
 132   GTK_CUPS_POST_DONE = GTK_CUPS_REQUEST_DONE
 133 };
 134
 135 /* GET states */
 136 enum
 137 {
 138   GTK_CUPS_GET_CONNECT = GTK_CUPS_REQUEST_START,
 139   GTK_CUPS_GET_SEND,
 140   GTK_CUPS_GET_CHECK,
 141   GTK_CUPS_GET_AUTH,
 142   GTK_CUPS_GET_READ_DATA,
 143   GTK_CUPS_GET_DONE = GTK_CUPS_REQUEST_DONE
 144 };
 145
 146 GtkCupsRequest        * gtk_cups_request_new_with_username (http_t             *connection,
 147                                                             GtkCupsRequestType  req_type,
 148                                                             gint                operation_id,
 149                                                             GIOChannel         *data_io,
 150                                                             const char         *server,
 151                                                             const char         *resource,
 152                                                             const char         *username);
 153 GtkCupsRequest        * gtk_cups_request_new               (http_t             *connection,
 154                                                             GtkCupsRequestType  req_type,
 155                                                             gint                operation_id,
 156                                                             GIOChannel         *data_io,
 157                                                             const char         *server,
 158                                                             const char         *resource);
 159 void                    gtk_cups_request_ipp_add_string    (GtkCupsRequest     *request,
 160                                                             ipp_tag_t           group,
 161                                                             ipp_tag_t           tag,
 162                                                             const char         *name,
 163                                                             const char         *charset,
 164                                                             const char         *value);
 165 void                    gtk_cups_request_ipp_add_strings   (GtkCupsRequest     *request,
 166                                                             ipp_tag_t           group,
 167                                                             ipp_tag_t           tag,
 168                                                             const char         *name,
 169                                                             int                 num_values,
 170                                                             const char         *charset,
 171                                                             const char * const *values);
 172 const char            * gtk_cups_request_ipp_get_string    (GtkCupsRequest     *request,
 173                                                             ipp_tag_t           tag,
 174                                                             const char         *name);
 175 gboolean                gtk_cups_request_read_write        (GtkCupsRequest     *request);
 176 GtkCupsPollState        gtk_cups_request_get_poll_state    (GtkCupsRequest     *request);
 177 void                    gtk_cups_request_free              (GtkCupsRequest     *request);
 178 GtkCupsResult         * gtk_cups_request_get_result        (GtkCupsRequest     *request);
 179 gboolean                gtk_cups_request_is_done           (GtkCupsRequest     *request);
 180 void                    gtk_cups_request_encode_option     (GtkCupsRequest     *request,
 181                                                             const gchar        *option,
 182                                                             const gchar        *value);
 183 gboolean                gtk_cups_result_is_error           (GtkCupsResult      *result);
 184 ipp_t                 * gtk_cups_result_get_response       (GtkCupsResult      *result);
 185 GtkCupsErrorType        gtk_cups_result_get_error_type     (GtkCupsResult      *result);
 186 int                     gtk_cups_result_get_error_status   (GtkCupsResult      *result);
 187 int                     gtk_cups_result_get_error_code     (GtkCupsResult      *result);
 188 const char            * gtk_cups_result_get_error_string   (GtkCupsResult      *result);
 189 GtkCupsConnectionTest * gtk_cups_connection_test_new       (const char            *server);
 190 GtkCupsConnectionState  gtk_cups_connection_test_get_state (GtkCupsConnectionTest *test);
 191 void                    gtk_cups_connection_test_free      (GtkCupsConnectionTest *test);
 192
 193 G_END_DECLS
 194 #endif