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, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifndef __GTK_CUPS_UTILS_H__
  19 #define __GTK_CUPS_UTILS_H__
  20
  21 #include <glib.h>
  22 #include <cups/cups.h>
  23 #include <cups/language.h>
  24 #include <cups/http.h>
  25 #include <cups/ipp.h>
  26
  27 G_BEGIN_DECLS
  28
  29 typedef struct _GtkCupsRequest        GtkCupsRequest;
  30 typedef struct _GtkCupsResult         GtkCupsResult;
  31 typedef struct _GtkCupsConnectionTest GtkCupsConnectionTest;
  32
  33 typedef enum
  34 {
  35   GTK_CUPS_ERROR_HTTP,
  36   GTK_CUPS_ERROR_IPP,
  37   GTK_CUPS_ERROR_IO,
  38   GTK_CUPS_ERROR_AUTH,
  39   GTK_CUPS_ERROR_GENERAL
  40 } GtkCupsErrorType;
  41
  42 typedef enum
  43 {
  44   GTK_CUPS_POST,
  45   GTK_CUPS_GET
  46 } GtkCupsRequestType;
  47
  48
  49 /**
  50  * Direction we should be polling the http socket on.
  51  * We are either reading or writting at each state.
  52  * This makes it easy for mainloops to connect to poll.
  53  */
  54 typedef enum
  55 {
  56   GTK_CUPS_HTTP_IDLE,
  57   GTK_CUPS_HTTP_READ,
  58   GTK_CUPS_HTTP_WRITE
  59 } GtkCupsPollState;
  60
  61 typedef enum
  62 {
  63   GTK_CUPS_CONNECTION_AVAILABLE,
  64   GTK_CUPS_CONNECTION_NOT_AVAILABLE,
  65   GTK_CUPS_CONNECTION_IN_PROGRESS
  66 } GtkCupsConnectionState;
  67
  68 typedef enum
  69 {
  70   GTK_CUPS_PASSWORD_NONE,
  71   GTK_CUPS_PASSWORD_REQUESTED,
  72   GTK_CUPS_PASSWORD_HAS,
  73   GTK_CUPS_PASSWORD_APPLIED,
  74   GTK_CUPS_PASSWORD_NOT_VALID
  75 } GtkCupsPasswordState;
  76
  77 struct _GtkCupsRequest
  78 {
  79   GtkCupsRequestType type;
  80
  81   http_t *http;
  82   http_status_t last_status;
  83   ipp_t *ipp_request;
  84
  85   gchar *server;
  86   gchar *resource;
  87   GIOChannel *data_io;
  88   gint attempts;
  89
  90   GtkCupsResult *result;
  91
  92   gint state;
  93   GtkCupsPollState poll_state;
  94   guint64 bytes_received;
  95
  96   gchar *password;
  97   gchar *username;
  98
  99   gint own_http : 1;
 100   gint need_password : 1;
 101   gint need_auth_info : 1;
 102   gchar **auth_info_required;
 103   gchar **auth_info;
 104   GtkCupsPasswordState password_state;
 105 };
 106
 107 struct _GtkCupsConnectionTest
 108 {
 109 #ifdef HAVE_CUPS_API_1_2
 110   GtkCupsConnectionState at_init;
 111   http_addrlist_t       *addrlist;
 112   http_addrlist_t       *current_addr;
 113   http_addrlist_t       *last_wrong_addr;
 114   gint                   socket;
 115 #endif
 116 };
 117
 118 #define GTK_CUPS_REQUEST_START 0
 119 #define GTK_CUPS_REQUEST_DONE 500
 120
 121 /* POST states */
 122 enum
 123 {
 124   GTK_CUPS_POST_CONNECT = GTK_CUPS_REQUEST_START,
 125   GTK_CUPS_POST_SEND,
 126   GTK_CUPS_POST_WRITE_REQUEST,
 127   GTK_CUPS_POST_WRITE_DATA,
 128   GTK_CUPS_POST_CHECK,
 129   GTK_CUPS_POST_AUTH,
 130   GTK_CUPS_POST_READ_RESPONSE,
 131   GTK_CUPS_POST_DONE = GTK_CUPS_REQUEST_DONE
 132 };
 133
 134 /* GET states */
 135 enum
 136 {
 137   GTK_CUPS_GET_CONNECT = GTK_CUPS_REQUEST_START,
 138   GTK_CUPS_GET_SEND,
 139   GTK_CUPS_GET_CHECK,
 140   GTK_CUPS_GET_AUTH,
 141   GTK_CUPS_GET_READ_DATA,
 142   GTK_CUPS_GET_DONE = GTK_CUPS_REQUEST_DONE
 143 };
 144
 145 GtkCupsRequest        * gtk_cups_request_new_with_username (http_t             *connection,
 146                                                             GtkCupsRequestType  req_type,
 147                                                             gint                operation_id,
 148                                                             GIOChannel         *data_io,
 149                                                             const char         *server,
 150                                                             const char         *resource,
 151                                                             const char         *username);
 152 GtkCupsRequest        * gtk_cups_request_new               (http_t             *connection,
 153                                                             GtkCupsRequestType  req_type,
 154                                                             gint                operation_id,
 155                                                             GIOChannel         *data_io,
 156                                                             const char         *server,
 157                                                             const char         *resource);
 158 void                    gtk_cups_request_ipp_add_string    (GtkCupsRequest     *request,
 159                                                             ipp_tag_t           group,
 160                                                             ipp_tag_t           tag,
 161                                                             const char         *name,
 162                                                             const char         *charset,
 163                                                             const char         *value);
 164 void                    gtk_cups_request_ipp_add_strings   (GtkCupsRequest     *request,
 165                                                             ipp_tag_t           group,
 166                                                             ipp_tag_t           tag,
 167                                                             const char         *name,
 168                                                             int                 num_values,
 169                                                             const char         *charset,
 170                                                             const char * const *values);
 171 const char            * gtk_cups_request_ipp_get_string    (GtkCupsRequest     *request,
 172                                                             ipp_tag_t           tag,
 173                                                             const char         *name);
 174 gboolean                gtk_cups_request_read_write        (GtkCupsRequest     *request,
 175                                                             gboolean            connect_only);
 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