rnetclient.c

   1 /*
   2  *  Copyright (C) 2012-2013  Thadeu Lima de Souza Cascardo <cascardo@minaslivre.org>
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 3 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program 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
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License along
  15  *  with this program; if not, write to the Free Software Foundation, Inc.,
  16  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include <string.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <errno.h>
  23 #include <unistd.h>
  24 #include <sys/socket.h>
  25 #include <netinet/in.h>
  26 #include <arpa/inet.h>
  27 #include <netdb.h>
  28 #include <gnutls/gnutls.h>
  29 #include <zlib.h>
  30 #include "decfile.h"
  31 #include "rnet_message.h"
  32 #include "rnet_encode.h"
  33
  34 static void * get_creds(char *certfile)
  35 {
  36         static gnutls_certificate_credentials_t cred;
  37         gnutls_certificate_allocate_credentials(&cred);
  38         gnutls_certificate_set_x509_trust_file(cred, certfile,
  39                                         GNUTLS_X509_FMT_PEM);
  40         return cred;
  41 }
  42
  43 static void session_new(gnutls_session_t *session)
  44 {
  45         static void *cred;
  46         cred = get_creds("cert.pem");
  47         gnutls_init(session, GNUTLS_CLIENT);
  48         gnutls_set_default_priority(*session);
  49         gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE, cred);
  50 }
  51
  52 static int deflateRecord(char *buffer, size_t len, char **out, size_t *olen, int header)
  53 {
  54         z_stream zstrm;
  55         int r;
  56         zstrm.zalloc = Z_NULL;
  57         zstrm.zfree = Z_NULL;
  58         zstrm.opaque = Z_NULL;
  59         if ((r = deflateInit(&zstrm, Z_DEFAULT_COMPRESSION)) != Z_OK)
  60                 return -1;
  61         *out = malloc(len * 2 + 36);
  62         if (!out) {
  63                 deflateEnd(&zstrm);
  64                 return -1;
  65         }
  66         zstrm.next_in = buffer;
  67         zstrm.avail_in = len;
  68         zstrm.next_out = *out + 6;
  69         zstrm.avail_out = len * 2 + 30;
  70         while ((r = deflate(&zstrm, Z_FINISH)) != Z_STREAM_END &&
  71                 zstrm.avail_out > 0);
  72         if ((r = deflate(&zstrm, Z_FINISH)) != Z_STREAM_END) {
  73                 deflateEnd(&zstrm);
  74                 free(*out);
  75                 return -1;
  76         }
  77         *olen = zstrm.total_out + 6;
  78         (*out)[0] = 0x1;
  79         (*out)[1] = (zstrm.total_out >> 8);
  80         (*out)[2] = (zstrm.total_out & 0xff);
  81         (*out)[3] = (len >> 8);
  82         (*out)[4] = (len & 0xff);
  83         (*out)[5] = header ? 0x01 : 0x0;
  84         deflateEnd(&zstrm);
  85         return 0;
  86 }
  87
  88 static int inflateRecord(char *buffer, size_t len, char **out, size_t *olen)
  89 {
  90         z_stream zstrm;
  91         int r;
  92         zstrm.zalloc = Z_NULL;
  93         zstrm.zfree = Z_NULL;
  94         zstrm.opaque = Z_NULL;
  95         if ((r = inflateInit(&zstrm)) != Z_OK)
  96                 return -1;
  97         *olen = (buffer[3] << 8 | buffer[4]);
  98         *out = malloc(*olen);
  99         if (!out) {
 100                 inflateEnd(&zstrm);
 101                 return -1;
 102         }
 103         zstrm.next_in = buffer + 6;
 104         zstrm.avail_in = len - 6;
 105         zstrm.next_out = *out;
 106         zstrm.avail_out = *olen;
 107         while ((r = inflate(&zstrm, Z_FINISH)) != Z_STREAM_END &&
 108                 zstrm.avail_out > 0);
 109         if ((r = inflate(&zstrm, Z_FINISH)) != Z_STREAM_END) {
 110                 inflateEnd(&zstrm);
 111                 free(*out);
 112                 return -1;
 113         }
 114         inflateEnd(&zstrm);
 115         return 0;
 116 }
 117
 118 #define RNET_ADDRESS "receitanet.receita.fazenda.gov.br"
 119
 120 static int connect_rnet(int *c)
 121 {
 122         struct addrinfo *addresses;
 123         struct addrinfo *addr;
 124         struct addrinfo hint;
 125         struct sockaddr_in saddr;
 126         int r;
 127         int fd = *c = -1;
 128         int i;
 129         memset(&hint, 0, sizeof(hint));
 130         hint.ai_family = AF_UNSPEC;
 131         hint.ai_socktype = SOCK_STREAM;
 132         hint.ai_protocol = IPPROTO_TCP;
 133         hint.ai_flags = AI_ADDRCONFIG;
 134         r = getaddrinfo(RNET_ADDRESS, "3456", &hint, &addresses);
 135         if (r) {
 136                 return r;
 137         }
 138         for (addr = addresses; addr != NULL; addr = addr->ai_next) {
 139                 fd = socket(addr->ai_family, addr->ai_socktype,
 140                                 addr->ai_protocol);
 141                 if (fd >= 0)
 142                         if (!(r = connect(fd, addr->ai_addr,
 143                                                 addr->ai_addrlen)))
 144                                 break;
 145                 close(fd);
 146                 fd = -1;
 147         }
 148         freeaddrinfo(addresses);
 149         *c = fd;
 150         if (fd == -1)
 151                 return EAI_SYSTEM;
 152         return 0;
 153 }
 154
 155 static int handshake(int c)
 156 {
 157         char buffer[16];
 158         int r;
 159         buffer[0] = 1;
 160         write(c, buffer, 1);
 161         write(c, "00000000000000", 14);
 162         r = read(c, buffer, 1);
 163         if (r != 1 && buffer[0] != 'E')
 164                 return -1;
 165         r = read(c, buffer, 14);
 166         if (r != 14)
 167                 return -1;
 168         return 0;
 169 }
 170
 171 static void usage(void)
 172 {
 173         fprintf(stderr, "rnetclient [filename]\n");
 174         exit(1);
 175 }
 176
 177 static int rnet_send(gnutls_session_t session, char *buffer, size_t len, int header)
 178 {
 179         char *out;
 180         size_t olen;
 181         deflateRecord(buffer, len, &out, &olen, header);
 182         gnutls_record_send(session, out, olen);
 183         free(out);
 184         return 0;
 185 }
 186
 187 static int rnet_recv(gnutls_session_t session, struct rnet_message **message)
 188 {
 189         char *out;
 190         size_t olen;
 191         int r;
 192         char *buffer;
 193         size_t len;
 194         rnet_message_expand(message, 6);
 195         buffer = (*message)->buffer;
 196         r = gnutls_record_recv(session, buffer, 6);
 197         if (buffer[0] == 0x01) {
 198                 len = (buffer[1] << 8 | buffer[2]);
 199                 rnet_message_expand(message, len);
 200                 buffer = (*message)->buffer + 6;
 201                 r = gnutls_record_recv(session, buffer, len);
 202                 inflateRecord(buffer - 6, len + 6, &out, &olen);
 203                 rnet_message_del(*message);
 204                 *message = NULL;
 205                 rnet_message_expand(message, olen);
 206                 memcpy((*message)->buffer, out, olen);
 207                 (*message)->len = olen;
 208                 free(out);
 209         } else {
 210                 len = (buffer[1] << 8 | buffer[2]);
 211                 rnet_message_expand(message, len - 1);
 212                 buffer = (*message)->buffer + 6;
 213                 r = gnutls_record_recv(session, buffer, len - 1);
 214                 (*message)->len = len + 4;
 215                 rnet_message_strip(*message, 4);
 216         }
 217         return 0;
 218 }
 219
 220 static void save_rec_file(char *cpf, char *buffer, int len)
 221 {
 222         int fd;
 223         char *filename;
 224         char *home, *tmpdir;
 225         mode_t mask;
 226         size_t fnlen;
 227         int r;
 228         home = getenv("HOME");
 229         if (!home) {
 230                 tmpdir = getenv("TMPDIR");
 231                 if (!tmpdir)
 232                         tmpdir = "/tmp";
 233                 home = tmpdir;
 234         }
 235         fnlen = strlen(home) + strlen(cpf) + 13;
 236         filename = malloc(fnlen);
 237         snprintf(filename, fnlen, "%s/%s.REC.XXXXXX", home, cpf);
 238         mask = umask(0177);
 239         fd = mkstemp(filename);
 240         if (fd < 0) {
 241                 fprintf(stderr, "Could not create receipt file: %s\n",
 242                                                 strerror(errno));
 243                 goto out;
 244         }
 245         r = write(fd, buffer, len);
 246         if (r != len) {
 247                 fprintf(stderr, "Could not write to receipt file%s%s\n",
 248                         r < 0 ? ": " : ".",
 249                         r < 0 ? strerror(errno) : "");
 250                 goto out;
 251         }
 252         fprintf(stderr, "Wrote the receipt to %s.\n", filename);
 253 out:
 254         close(fd);
 255         free(filename);
 256         umask(mask);
 257 }
 258
 259 static void handle_response_text_and_file(char *cpf, struct rnet_message *message)
 260 {
 261         char *value;
 262         int vlen;
 263         if (!rnet_message_parse(message, "texto", &value, &vlen))
 264                 fprintf(stderr, "%.*s\n", vlen, value);
 265         if (!rnet_message_parse(message, "arquivo", &value, &vlen))
 266                 save_rec_file(cpf, value, vlen);
 267 }
 268
 269 static void handle_response_already_found(char *cpf, struct rnet_message *message)
 270 {
 271         handle_response_text_and_file(cpf, message);
 272 }
 273
 274 static void handle_response_error(struct rnet_message *message)
 275 {
 276         char *value;
 277         int vlen;
 278         if (!rnet_message_parse(message, "texto", &value, &vlen))
 279                 fprintf(stderr, "%.*s\n", vlen, value);
 280         fprintf(stderr, "Error transmiting DEC file.\n");
 281 }
 282
 283 int main(int argc, char **argv)
 284 {
 285         int c;
 286         int r;
 287         struct rnet_decfile *decfile;
 288         struct rnet_message *message = NULL;
 289         gnutls_session_t session;
 290         int finish = 0;
 291         char *cpf;
 292
 293         if (argc < 2) {
 294                 usage();
 295         }
 296
 297         decfile = rnet_decfile_open(argv[1]);
 298         if (!decfile) {
 299                 fprintf(stderr, "could not parse %s: %s\n", argv[1], strerror(errno));
 300                 exit(1);
 301         }
 302
 303         cpf = rnet_decfile_get_header_field(decfile, "cpf");
 304
 305         gnutls_global_init();
 306
 307         session_new(&session);
 308         r = connect_rnet(&c);
 309         if (r) {
 310                 fprintf(stderr, "error connecting to server: %s\n",
 311                         r == EAI_SYSTEM ? strerror(errno) : gai_strerror(r));
 312                 exit(1);
 313         }
 314         gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) c);
 315         r = handshake(c);
 316         if (r < 0) {
 317                 exit(1);
 318         }
 319         if ((r = gnutls_handshake(session)) < 0)
 320                 fprintf(stderr, "error in handshake: %s\n",
 321                                 gnutls_strerror(r));
 322
 323         rnet_encode(decfile, &message);
 324         rnet_send(session, message->buffer, message->len, 1);
 325         rnet_message_del(message);
 326
 327         message = NULL;
 328         r = rnet_recv(session, &message);
 329         if (r || !message || message->len == 0) {
 330                 fprintf(stderr, "error when receiving response\n");
 331                 goto out;
 332         }
 333         switch (message->buffer[0]) {
 334         case 1: /* go ahead */
 335                 handle_response_text_and_file(cpf, message);
 336                 break;
 337         case 3: /* error */
 338                 handle_response_error(message);
 339                 finish = 1;
 340                 break;
 341         case 4:
 342                 handle_response_already_found(cpf, message);
 343                 finish = 1;
 344                 break;
 345         case 2:
 346         case 5:
 347                 handle_response_text_and_file(cpf, message);
 348                 finish = 1;
 349                 break;
 350         }
 351         rnet_message_del(message);
 352
 353         if (finish)
 354                 goto out;
 355
 356         message = rnet_decfile_get_file(decfile);
 357         rnet_send(session, message->buffer, message->len, 0);
 358
 359         message = NULL;
 360         r = rnet_recv(session, &message);
 361         if (r || !message || message->len == 0) {
 362                 fprintf(stderr, "error when receiving response\n");
 363                 goto out;
 364         }
 365         switch (message->buffer[0]) {
 366         case 3: /* error */
 367                 handle_response_error(message);
 368                 break;
 369         case 2:
 370         case 4:
 371         case 5:
 372         case 1:
 373                 handle_response_text_and_file(cpf, message);
 374                 break;
 375         }
 376
 377 out:
 378         gnutls_bye(session, GNUTLS_SHUT_RDWR);
 379         close(c);
 380         rnet_decfile_close(decfile);
 381         gnutls_global_deinit();
 382
 383         return 0;
 384 }