28451f634248f527c6329c53574d9dbc9d338f73
[gpgme.git] / assuan / mkerrors
1 #!/bin/sh
2 # mkerrors - Extract error strings from assuan.h
3 #            and create C source for assuan_strerror
4 #       Copyright (C) 2001, 2002, 2006 Free Software Foundation, Inc.
5 #
6 # This file is part of Assuan.
7 #
8 # Assuan is free software; you can redistribute it and/or modify it
9 # under the terms of the GNU Lesser General Public License as
10 # published by the Free Software Foundation; either version 2.1 of
11 # the License, or (at your option) any later version.
12 #
13 # Assuan is distributed in the hope that it will be useful, but
14 # WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16 # Lesser General Public License for more details.
17 #
18 # You should have received a copy of the GNU Lesser General Public
19 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
20 cat <<EOF
21 /* Generated automatically by mkerrors */
22 /* Do not edit!  See mkerrors for copyright notice. */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <stdio.h>
29 #include <assert.h>
30 #include <errno.h>
31
32 #undef _ASSUAN_IN_LIBASSUAN /* undef to get all error codes. */
33 #include "assuan.h"
34
35 /* If true the modern gpg-error style error codes are used in the
36    API. */
37 static unsigned int err_source;
38
39 /* Enable gpg-error style error codes.  ERRSOURCE is one of gpg-error
40    sources.  Note, that this function is not thread-safe and should be
41    used right at startup. Switching back to the old style mode is not
42    supported. */
43 void
44 assuan_set_assuan_err_source (int errsource)
45 {
46   errsource &= 0xff;
47   err_source = errsource? errsource : 31 /*GPG_ERR_SOURCE_ANY*/;
48 }
49
50
51 /* Helper to map old style Assuan error codes to gpg-error codes.
52    This is used internally to keep an compatible ABI. */
53 assuan_error_t
54 _assuan_error (int oldcode)
55 {
56   unsigned int n;
57
58   if (!err_source)
59     {
60       if (oldcode == -1)
61         return -1;
62       else
63         return (oldcode & 0x00ffffff); /* Make sure that the gpg-error
64                                           source part is cleared. */
65     }
66
67   switch (oldcode)
68     {
69     case ASSUAN_General_Error:           n = 257; break;
70     case ASSUAN_Accept_Failed:           n = 258; break;
71     case ASSUAN_Connect_Failed:          n = 259; break;
72     case ASSUAN_Invalid_Response:        n = 260; break;
73     case ASSUAN_Invalid_Value:           n = 261; break;
74     case ASSUAN_Line_Not_Terminated:     n = 262; break;
75     case ASSUAN_Line_Too_Long:           n = 263; break;
76     case ASSUAN_Nested_Commands:         n = 264; break;
77     case ASSUAN_No_Data_Callback:        n = 265; break;
78     case ASSUAN_No_Inquire_Callback:     n = 266; break;
79     case ASSUAN_Not_A_Server:            n = 267; break;
80     case ASSUAN_Not_Implemented:         n =  69; break;
81     case ASSUAN_Parameter_Conflict:      n = 280; break;
82     case ASSUAN_Problem_Starting_Server: n = 269; break;
83     case ASSUAN_Server_Fault:            n =  80; break;
84     case ASSUAN_Syntax_Error:            n = 276; break;
85     case ASSUAN_Too_Much_Data:           n = 273; break;
86     case ASSUAN_Unexpected_Command:      n = 274; break;
87     case ASSUAN_Unknown_Command:         n = 275; break;
88     case ASSUAN_Canceled:                n = 277; break;
89     case ASSUAN_No_Secret_Key:           n =  17; break;
90     case ASSUAN_Not_Confirmed:           n = 114; break;
91
92     case ASSUAN_Read_Error:
93       switch (errno)
94         {
95         case 0: n = 16381; /*GPG_ERR_MISSING_ERRNO*/  break;
96         case EAGAIN:
97           if (errno > 0 && errno < 4096)
98             {
99               n = (EAGAIN | (1 << 15)); 
100               break;
101             }
102         default: n = 270;  /*GPG_ERR_ASS_READ_ERROR*/ break;
103         }
104       break;
105
106     case ASSUAN_Write_Error:
107       switch (errno)
108         {
109         case 0: n = 16381; /*GPG_ERR_MISSING_ERRNO*/  break;
110         case EAGAIN:
111           if (errno > 0 && errno < 4096)
112             {
113               n = (EAGAIN | (1 << 15)); 
114               break;
115             }
116         default: n = 271;  /*GPG_ERR_ASS_WRITE_ERROR*/ break;
117         }
118       break;
119       
120     case ASSUAN_Out_Of_Core:
121       switch (errno)
122         {
123         case 0:  /* Should not happen but a user might have provided
124                     an incomplete implemented malloc function.  Give
125                     him a chance to correct this fault but make sure
126                     an error is indeed returned. */
127           n = 16381; /*GPG_ERR_MISSING_ERRNO*/
128           break;
129         case ENOMEM:
130           if (errno > 0 && errno < 4096)
131             {
132               n = (ENOMEM | (1 << 15));
133               break;
134             }
135         default:  
136           n = 16382; /*GPG_ERR_UNKNOWN_ERRNO*/
137           break;
138         }
139       break;
140
141     case -1: n = 16383 /*GPG_ERR_EOF*/; break;
142
143     default:
144       n = 257; 
145       break;
146     }
147
148   return ((err_source << 24) | (n & 0x00ffffff));
149
150 }
151
152
153 /**
154  * assuan_strerror:
155  * @err:  Error code 
156  * 
157  * This function returns a textual representaion of the given
158  * errorcode. If this is an unknown value, a string with the value
159  * is returned (Beware: it is hold in a static buffer).
160  * 
161  * Return value: String with the error description.
162  **/
163 const char *
164 assuan_strerror (assuan_error_t err)
165 {
166   const char *s;
167   static char buf[50];
168
169   switch (err)
170     {
171 EOF
172
173 awk '
174 /ASSUAN_No_Error/        { okay=1 }
175 !okay                    {next}
176 /^#define[ ]+ASSUAN_[A-Za-z_]*/ { print_code($2) }
177 /ASSUAN_USER_ERROR_LAST/ { exit 0 }
178
179
180 function print_code( s )
181 {
182 printf "    case %s: s=\"", s ;
183 gsub(/_/, " ", s );
184 printf "%s\"; break;\n", tolower(substr(s,8));
185 }
186 '
187
188 cat <<EOF
189   case -1: s = "EOF (-1)"; break;
190     default: 
191       {
192         unsigned int source, code, n;
193
194         source = ((err >> 24) & 0xff);
195         code = (err & 0x00ffffff);
196         if (source) 
197           {
198             /* Assume this is an libgpg-error and try to map the codes
199                back. */
200             switch (code)
201               {
202               case 257: n = ASSUAN_General_Error          ; break;
203               case 258: n = ASSUAN_Accept_Failed          ; break;
204               case 259: n = ASSUAN_Connect_Failed         ; break;
205               case 260: n = ASSUAN_Invalid_Response       ; break;
206               case 261: n = ASSUAN_Invalid_Value          ; break;
207               case 262: n = ASSUAN_Line_Not_Terminated    ; break;
208               case 263: n = ASSUAN_Line_Too_Long          ; break;
209               case 264: n = ASSUAN_Nested_Commands        ; break;
210               case 265: n = ASSUAN_No_Data_Callback       ; break;
211               case 266: n = ASSUAN_No_Inquire_Callback    ; break;
212               case 267: n = ASSUAN_Not_A_Server           ; break;
213               case  69: n = ASSUAN_Not_Implemented        ; break;
214               case 280: n = ASSUAN_Parameter_Conflict     ; break;
215               case 269: n = ASSUAN_Problem_Starting_Server; break;
216               case 270: n = ASSUAN_Read_Error             ; break;
217               case 271: n = ASSUAN_Write_Error            ; break;
218               case  80: n = ASSUAN_Server_Fault           ; break;
219               case 276: n = ASSUAN_Syntax_Error           ; break;
220               case 273: n = ASSUAN_Too_Much_Data          ; break;
221               case 274: n = ASSUAN_Unexpected_Command     ; break;
222               case 275: n = ASSUAN_Unknown_Command        ; break;
223               case 277: n = ASSUAN_Canceled               ; break;
224               case 114: n = ASSUAN_Not_Confirmed          ; break;
225               case ((1<<15)|86): n = ASSUAN_Out_Of_Core   ; break;
226               default:  n = 0; break;
227               }
228             if (n)
229               s = assuan_strerror (n);
230             else
231               {
232                 sprintf (buf, "ec=%u.%u", source, code ); 
233                 s=buf;
234               }
235           }
236         else
237           {
238             sprintf (buf, "ec=%d", err ); 
239             s=buf;
240           }
241       }
242       break;
243     }
244
245   return s;
246 }
247
248 EOF