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