/* dump.c - chan_ss7/mtp3d dump
 *
 * Copyright (C) 2006-2011 Netfors ApS.
 *
 * Author: Anders Baekgaard <ab@netfors.com>
 *
 * This file is part of chan_ss7.
 *
 * chan_ss7 is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * chan_ss7 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with chan_ss7; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */


#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include <unistd.h>
#include <sys/poll.h>
#include <netinet/in.h>

#include "astversion.h"
#include "config.h"
#include "mtp3io.h"
#include "mtp.h"
#include "dump.h"


#ifdef MTP_STANDALONE
#include "aststubs.h"
#undef pthread_mutex_destroy
#undef pthread_mutex_lock
#undef pthread_mutex_unlock
#define ast_mutex_destroy pthread_mutex_destroy
#define ast_mutex_lock pthread_mutex_lock
#define ast_mutex_unlock pthread_mutex_unlock
#else
#include "asterisk.h"
#include "asterisk/channel.h"
#include "asterisk/module.h"
#include "asterisk/logger.h"
#include "asterisk/options.h"
#include "asterisk/utils.h"
#include "asterisk/sched.h"
#include "asterisk/cli.h"
#include "asterisk/lock.h"
#endif

/* State for dumps. */
AST_MUTEX_DEFINE_STATIC(dump_mutex);
static FILE *dump_in_fh = NULL;
static FILE *dump_out_fh = NULL;
static int dump_do_fisu, dump_do_lssu, dump_do_msu;


static void dump_pcap(FILE *f, struct mtp_event *event)
{
  unsigned int sec  = event->dump.stamp.tv_sec;
  unsigned int usec  = event->dump.stamp.tv_usec - (event->dump.stamp.tv_usec % 1000) +
    event->dump.sls*2 + /* encode link number in usecs */
    event->dump.out /* encode direction in/out */;
  int res;

  res = fwrite(&sec, sizeof(sec), 1, f);
  res = fwrite(&usec, sizeof(usec), 1, f);
  res = fwrite(&event->len, sizeof(event->len), 1, f); /* number of bytes of packet in file */
  res = fwrite(&event->len, sizeof(event->len), 1, f); /* actual length of packet */
  res = fwrite(event->buf, 1, event->len, f);
  if (res <= 0)
    ast_log(LOG_WARNING, "Unable to write on pcap file, res: %d, error: %s\n", res, strerror(errno));
  fflush(f);
}

int dump_enabled(struct mtp_event *event)
{
  FILE *dump_fh;

  if(event->dump.out) {
    dump_fh = dump_out_fh;
  } else {
    dump_fh = dump_in_fh;
  }

  if(dump_fh != NULL) {
    if(event->len < 3 ||
       ( !(event->buf[2] == 0 && !dump_do_fisu) &&
	 !((event->buf[2] == 1 || event->buf[2] == 2) && !dump_do_lssu) &&
	 !(event->buf[2] > 2 && !dump_do_msu)))
      return 1;
  }
  return 0;
}

void dump_event(struct mtp_event *event)
{
  FILE *dump_fh;

  ast_mutex_lock(&dump_mutex);

  if(event->dump.out) {
    dump_fh = dump_out_fh;
  } else {
    dump_fh = dump_in_fh;
  }
  if (dump_enabled(event))
      dump_pcap(dump_fh, event);
  ast_mutex_unlock(&dump_mutex);
}

static void init_pcap_file(FILE *f)
{
  unsigned int magic = 0xa1b2c3d4;  /* text2pcap does this */
  unsigned short version_major = 2;
  unsigned short version_minor = 4;
  unsigned int thiszone = 0;
  unsigned int sigfigs = 0;
  unsigned int snaplen = 102400;
  unsigned int linktype = 140;
  int res;

  res = fwrite(&magic, sizeof(magic), 1, f);
  res = fwrite(&version_major, sizeof(version_major), 1, f);
  res = fwrite(&version_minor, sizeof(version_minor), 1, f);
  res = fwrite(&thiszone, sizeof(thiszone), 1, f);
  res = fwrite(&sigfigs, sizeof(sigfigs), 1, f);
  res = fwrite(&snaplen, sizeof(snaplen), 1, f);
  res = fwrite(&linktype, sizeof(linktype), 1, f);
  if (res <= 0)
    ast_log(LOG_WARNING, "Unable to write on pcap file, res: %d, error: %s\n", res, strerror(errno));
}


int init_dump(int fd, const char* fn, int in, int out, int fisu, int lssu, int msu)
{
  FILE *fh;

  ast_mutex_lock(&dump_mutex);
  if((in && dump_in_fh != NULL) || (out && dump_out_fh != NULL)) {
    ast_cli(fd, "Dump already running, must be stopped (with 'ss7 dump stop') "
            "before new can be started.\n");
    ast_mutex_unlock(&dump_mutex);
    return -1;
  }


  fh = fopen(fn, "w");
  if(fh == NULL) {
    ast_cli(fd, "Error opening file '%s': %s.\n", fn, strerror(errno));
    ast_mutex_unlock(&dump_mutex);
    return -1;
  }

  if(in) {
    dump_in_fh = fh;
  }
  if(out) {
    dump_out_fh = fh;
  }
  dump_do_fisu = fisu;
  dump_do_lssu = lssu;
  dump_do_msu = msu;
  init_pcap_file(fh);


  ast_mutex_unlock(&dump_mutex);
  return 0;
}


void cleanup_dump(int fd, int in, int out)
{
  ast_mutex_lock(&dump_mutex);

  if((in && !out && dump_in_fh == NULL) ||
     (out && !in && dump_out_fh == NULL) ||
     (in && out && dump_in_fh == NULL && dump_out_fh == NULL)) {
    if (fd)
      ast_cli(fd, "No dump running.\n");
    ast_mutex_unlock(&dump_mutex);
    return;
  }

  if(in && dump_in_fh != NULL) {
    if(dump_out_fh == dump_in_fh) {
      /* Avoid closing it twice. */
      dump_out_fh = NULL;
    }
    fclose(dump_in_fh);
    dump_in_fh = NULL;
  }
  if(out && dump_out_fh != NULL) {
    fclose(dump_out_fh);
    dump_out_fh = NULL;
  }
  ast_mutex_unlock(&dump_mutex);
}


void dump_status(int fd)
{
  ast_mutex_lock(&dump_mutex);

  /* ToDo: This doesn't seem to work, the output is getting lost somehow.
     Not sure why, but could be related to ast_carefulwrite() called in
     ast_cli(). */
  ast_cli(fd, "Yuck! what is going on here?!?\n");
  if(dump_in_fh != NULL) {
    ast_cli(fd, "Dump of incoming frames is running.\n");
  }
  if(dump_out_fh != NULL) {
    ast_cli(fd, "Dump of outgoing frames is running.\n");
  }
  if(dump_in_fh != NULL || dump_out_fh != NULL) {
    ast_cli(fd, "Filter:%s%s%s.\n",
            (dump_do_fisu ? " fisu" : ""),
            (dump_do_lssu ? " lssu" : ""),
            (dump_do_msu ? " msu" : ""));
  }

  ast_mutex_unlock(&dump_mutex);
}