网管系统与OAM的封包解包

#include <stdio.h>
#include "telnet.h"
#include "command.h"


char resultBuf[4096] = {0};
int main(int argc, char *argv[])
{
    char *store;
   // telnet_command_init();
    parse_cmd_resp_packet("show DeviceInfo;", "AdditionalSoftwareVersion", store);
    return 0;
}
/*--------------------------command.c---------------------------------------------------*/
#include "telnet.h"
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <time.h>


#define SERVER_IP "192.168.100.111" //板子的IP
#define SERVER_PORT 50000
#define RECV_SIZE 4096
#define SEND_SIZE 2048


int telnet_command_init(void)
{
    int ret;
extern int m_sock_fd;
    char send_buff[SEND_SIZE] = {0};
    char recv_buff[RECV_SIZE] = {0};


    while(1)
{
Reconnection:
        sock_client_free();
        ret = telnet_client_init(SERVER_IP, SERVER_PORT);
        if(0 == ret)
{
            PDEBUG(L_CRIT, "Telnet client init was failed!\n");
sleep(1);
continue;
}
        PDEBUG(L_DEBUG, "Telnet client init was successful!\n");
while(1)
{
            strcpy(recv_buff, "");
            ret = TelnetRecv(recv_buff);
            if(ret < 0)
            {
                PDEBUG(L_CRIT, "Telnet client recv messages were error!\n");
                continue;
            }
            else if(0 == ret)
            {
                PDEBUG(L_WARNING, "Telnet link were shutdown by peer server, create telnet link again!\n");
                goto Reconnection;
            }
            PDEBUG(L_DEBUG, "recv buff: %s\n", recv_buff);
            if(strstr(recv_buff, "user"))
{
                strcat(send_buff, "webroot\r\n");
TelnetSend(send_buff);
continue;
}

            if(strstr(recv_buff, "pwd"))
{
                strcat(send_buff, "webroot\r\n");
TelnetSend(send_buff);
                strcat(send_buff, "show DeviceInfo;");
                recv(m_sock_fd, recv_buff, RECV_SIZE, MSG_WAITALL);


return 1;
}
}
}


return 0;
}


int telnet_send_cmd_mesg(const char* command, char* resp)
{
    int ret = 0;
    extern int m_sock_fd;
    char recv_buff[RECV_SIZE] = {0};
    char send_buff[SEND_SIZE] = {0};


    if(-1 == m_sock_fd)
{
        while(1)
        {
            ret = telnet_command_init();
            if(0 == ret)
            {
                PDEBUG(L_CRIT, "Telnet client init was failed!\n");
                sleep(1);
                continue;
            }
            break;
        }
}


    if(NULL == command)
    {
        PDEBUG(L_CRIT, "Telnet command was NULL, please confirm the command is right!\n");
        return 0;
    }
    memset(send_buff, 0, sizeof(send_buff));
    strncpy(send_buff, command, sizeof(send_buff));
    strncat(send_buff, "\r\n", sizeof(send_buff));

    ret = send(m_sock_fd, send_buff, strlen(send_buff), MSG_NOSIGNAL);
    if(ret < 0)
{
        PDEBUG(L_WARNING, "Socket client send messages was failed, convert telnet type to send message continue!\n");
        if(m_sock_fd < 0)
        {
            while(1)
            {
                if(!telnet_command_init())
                {
                    PDEBUG(L_CRIT, "Telnet client init was failed!\n");
                    sleep(1);
                    continue;
                }
                break;
            }
        }
        ret = TelnetSend(send_buff);
        if(0 == ret)
{
            PDEBUG(L_CRIT, "Telnet client send message were failed!\n");
return 0;
}
}


    while(1)
{
        ret = recv(m_sock_fd, recv_buff, RECV_SIZE, MSG_WAITALL);
       // PDEBUG(L_DEBUG, "recv messages: %s\n", recv_buff);
if(-1 == ret && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ||errno==2))
            continue;


        if(0 == ret)
{
            PDEBUG(L_WARNING, "the connect were shutdown by peer server!\n");
            if(0 == telnet_command_init())
{
                PDEBUG(L_CRIT, "telnet command init was failed!\n");
return 0;
}
            ret = send(m_sock_fd, send_buff, strlen(send_buff), 0);
            if(ret < 0)
{
                PDEBUG(L_WARNING, "Socket client send messages was failed, convert telnet type to send message continue!\n");
                ret = TelnetSend(send_buff);
                if(0 == ret)
{
                    PDEBUG(L_CRIT, "telnet send messages were failed!\n");
return 0;
}
                continue;
}
}
        else if(ret < 0)
{
            PDEBUG(L_WARNING, "Socket client recv messages was failed, continue recv ...\n");
            continue;
        }


        if(NULL != strstr(recv_buff, "#"))
{
            strncpy(resp, recv_buff, RECV_SIZE);
break;
        }
        continue;
} 


    return 1;
}


int command_init(const char *cmd, char *resp)
{
    int ret;


    ret = telnet_command_init();
    if(0 == ret)
    {
        PDEBUG(L_CRIT, "telnet_command_init was failed!\n");
        return 0;
    }


    ret = telnet_send_cmd_mesg(cmd, resp);
    if(0 == ret)
    {
        PDEBUG(L_CRIT, "telnet_send_cmd_mesg was failed!\n");
        return 0;
    }


    return 1;
}


int parse_cmd_resp_packet(const char *cmd, const char *key, void *store)
{
    int ret;
    int i;
    char *substr, *ptr;
    char tmp[RECV_SIZE] = {0};
    char rcv_buf[RECV_SIZE] = {0};


    ret = telnet_send_cmd_mesg(cmd, rcv_buf);
    if(0 == ret)
    {
        PDEBUG(L_CRIT, "telnet send command was failed!\n");
        return 0;
    }
    PDEBUG(L_DEBUG, "recv buff: %s\n", rcv_buf);


    //the rcv messages were by divided "\r\n", if there are n num"\r\n", there are (n + 1) partions;
    substr = strtok(rcv_buf, "\r\n");
    if(NULL == substr)
    {
        PDEBUG(L_CRIT, "Not found the sub string!\n");
        return 0;
    }


    //decide the respond messages by the first line;
    ptr = strstr(substr, "error");
    if(ptr)
    {
        PDEBUG(L_CRIT, "the respond messages were error!\n");
        return 0;
    }


    // the substr pointed to each line;
    while(substr)
    {
        substr = strtok(NULL, "\r\n");
        ptr = strstr(substr, key);
        if(ptr)
        {
            PDEBUG(L_DEBUG, "%s\n", substr);
            ptr = strtok(substr, "=");
            if(NULL == ptr)
            {
                PDEBUG(L_CRIT, "Not found the sub string!\n");
                return 0;
            }
            ptr = strtok(NULL, "=");
            if(NULL == ptr)
            {
                PDEBUG(L_CRIT, "Not found the sub string!\n");
                return 0;
            }
            PDEBUG(L_DEBUG, "%s\n", ptr);
            // cut the ' 'and '"' int the beginning of the line
            while (*ptr == ' ' || *ptr == '"')
            {
                 ptr++;
            }


            i = 0;
            while(*ptr != '\0')
            {
                if(*ptr == '"')
                   break;
                //PDEBUG(L_DEBUG, "%c, %d\n", *ptr, *ptr);
                tmp[i++] = *ptr++;
            }
            PDEBUG(L_DEBUG, "%s\n", tmp);
            break;
        }
    }


    return 1;
/*------------------------------------------------------------------------------------------------------*/
// Implementation of the Telnet class
#include <stdio.h>
#include "telnet.h"
#include "Socket.h"


#define NUM_TERMINALS 2
#define NUM_CODEC 6


//static unsigned long sa = COLOR_WHITE;
#define NUL     0
#define BEL     7
#define BS      8
#define HT      9
#define LF     10
#define VT     11
#define FF     12
#define CR     13
#define SE    240
#define NOP   241
#define DM    242
#define BRK   243
#define IP    244
#define AO    245
#define AYT   246
#define EC    247
#define EL    248
#define GA    249
#define SB    250
#define WILL  251
#define WONT  252
#define DO    253
#define DONT  254
#define IAC   255


typedef void(*LPCODEPROC) (char*);
typedef void(*LPOPTIONPROC) (_verb,_option);
typedef int(*LPDATAPROC) (unsigned char data);


static void ddww_error(_verb verb,_option option);
static void ddww_echo(_verb verb, _option option);
static void ddww_supp(_verb verb,_option option); //Suppress GA
static void ddww_term(_verb verb,_option option); //Subnegotiate terminal type


static int nvt(unsigned char data);
static int ansi(unsigned char data);
static int sbproc_term(unsigned char data);


static void ansi_set_screen_attribute(char* buffer);
static void ansi_set_position(char* buffer);
static void ansi_erase_screen(char* buffer);
static void ansi_move_up(char* buffer);
static void ansi_erase_line(char* buffer);


int option_error(_verb, _option, int, int);


struct codec_t
{
unsigned char cmd;
LPCODEPROC proc;
};
struct codec_t codec[6] = {
{'m', ansi_set_screen_attribute},
{'H', ansi_set_position},
{'K', ansi_erase_line},
{'J', ansi_erase_screen},
{'A', ansi_move_up},
{0, 0}
};


struct
{
char* name;
LPDATAPROC termproc;
} terminal[NUM_TERMINALS] = {
{ "NVT", nvt }, 
{ "ANSI", ansi }
};


//
// Construction/Destruction
//
//int nvt(unsigned char data);
typedef enum 
{
as_normal,
as_esc,
as_esc1
} _ansi_state;


enum
{
SB_TERM_IS = 0,
SB_TERM_SEND = 1
};


char codebuf[256];
unsigned char codeptr;
int term_index = 0;


int telnet_client_init ( const char* host, const int port )
{
    initSocket();
if(!create())
{
printf( "Could not create client socket.\n" );
return 0;
}
if(!socketConnect (host,port))
{
printf( "Could not create connect socket.\n" );
return 0;
}


return 1;
}


void yesreply(_verb verb,_option option) 
{
unsigned char buf[3];


buf[0] = IAC;
buf[1] = (verb==verb_do)?WILL:(verb==verb_dont)?WONT:(verb==verb_will)?DO:DONT;
buf[2] = (unsigned char)option;
socketSend((char*)buf,3);
}


void noreply(_verb verb,_option option) 
{
unsigned char buf[3];


buf[0] = IAC;
buf[1] = (verb==verb_do)?WONT:(verb == verb_dont)?WILL : (verb == verb_will)?DONT:DO;
buf[2] = (unsigned char)option;
socketSend((char*)buf,3);
}


void askfor(_verb verb,_option option) 
{
unsigned char buf[3];


buf[0] = IAC;
buf[1] = (unsigned char)verb;
buf[2] = (unsigned char)option;
socketSend((char*)buf, 3);
}


static void ddww_error(_verb verb, _option option)
{
switch(verb)
{
case verb_will: 
noreply(verb,option);
break;
case verb_wont:
return;
case verb_do:
noreply(verb,option);
break;
case verb_dont:
return;
}
}


static void ddww_echo(_verb verb, _option option)
{
int mode;
int set = !(mode & 0xFF);


switch(verb)
{
case verb_will: // server wants to echo stuff
if(set) return; //don't confirm - already set.
break;
case verb_wont: // server don't want to echo
if(!set) return; //don't confirm - already unset.
break;
case verb_do:   // server wants me to loopback
noreply(verb,option);
return;
case verb_dont: // server doesn't want me to echo
break;        // don't bother to reply - I don't
}


yesreply(verb, option);
}


static void ddww_supp(_verb verb, _option option) //Suppress GA
{


unsigned long mode;
int set = !(mode & 0xFF);

switch(verb)
{
case verb_will: // server wants to suppress GA's
if(set) break; //don't confirm - already set.
askfor(verb_do,TOPT_SUPP);
askfor(verb_will,TOPT_SUPP);
askfor(verb_do,TOPT_ECHO);
break;
case verb_wont: // server wants to send GA's 
if(!set) break; //don't confirm - already unset.
askfor(verb_dont,TOPT_SUPP);
askfor(verb_wont,TOPT_SUPP);
break;
case verb_do:   // server wants me to suppress GA's
if(set) break;
askfor(verb_do,TOPT_SUPP);
break;
case verb_dont: // server wants me to send GA's
if(!set) break;
askfor(verb_dont,TOPT_SUPP);
break;
}
}


///
// Option TERMINAL-TYPE


static void ddww_term(_verb verb, _option option) //Subnegotiate terminal type
{
switch(verb)
{
case verb_will:
noreply(verb, option); // I don't want terminal info
break;
case verb_wont:
break;
case verb_do:
yesreply(verb, option); //I'll send it when asked
break;
case verb_dont://Ok - I won't
break;
}
}


void termreply(unsigned char data) 
{
  if(data == SB_TERM_SEND)
  {
    if(term_index == NUM_TERMINALS)
      term_index = 0;
    else
      term_index++;
    char buf[16]; //pls limit 
    buf[0] = IAC;
    buf[1] = SB;
    buf[2] = TOPT_TERM;
    buf[3] = SB_TERM_IS;
    strcpy(&buf[4],terminal[(term_index==NUM_TERMINALS)?(NUM_TERMINALS-1):term_index].name);
    int nlen = strlen(&buf[4]);
    buf[4+nlen] = IAC;
    buf[5+nlen] = SE;
    socketSend(buf,4+nlen+2);
  }
}


static int sbproc_term(unsigned char data)
{
termreply(data);
return 0;
}


///


struct
{
_option option;
LPOPTIONPROC OptionProc;
LPDATAPROC DataProc;
} ol[] = {
{TOPT_ECHO,   ddww_echo,  NULL},
{TOPT_SUPP,   ddww_supp,  NULL},
{TOPT_TERM,   ddww_term,  sbproc_term},
{TOPT_ERROR,  ddww_error, NULL}
};


LPDATAPROC DataProc;
int TelentProtcol(unsigned char code) 
{
static int state = state_data;
static _verb verb = verb_sb;
int i;


DataProc = terminal[(term_index==NUM_TERMINALS)?(NUM_TERMINALS-1):term_index].termproc;;

switch(state)
{
case state_data:
switch(code)
{
case IAC: state = state_code; break;
default: return DataProc(code);
}
break;
case state_code:
 state = state_data;
 switch(code)
 {
 // State transition back to data
 case NOP:
 case DM:
 case BRK:
 case IP:
 case AO:
 case AYT:
 case EC:
 case EL:
 case GA:
break;
 case IAC: 
   DataProc(code);
   break;
 // Code state transitions back to data
 case SE:
   DataProc = terminal[(term_index==NUM_TERMINALS)?(NUM_TERMINALS-1):term_index].termproc;
   break;
 // Transitions to option state
 case SB:
   verb = verb_sb;
   state = state_option;
   break;
 case WILL:
   verb = verb_will;
   state = state_option;
   break;
 case WONT:
   verb = verb_wont;
   state = state_option;
   break;
 case DO:
   verb = verb_do;
   state = state_option;
   break;
 case DONT:
   verb = verb_dont;
   state = state_option;
   break;
 }
 break;
case state_option:
 state = state_data;

 //Find the option entry
 for(
   i = 0;
   ol[i].option != TOPT_ERROR && ol[i].option != code;
   i++);

 //Do some verb specific stuff
 if(verb == verb_sb)
   DataProc = ol[i].DataProc;
 else
   ol[i].OptionProc(verb,(_option)code);
 break;
}
return 0;
}


static int nvt(unsigned char data)
{
if(0 == data)
{
return 0;
}


return 1;
}


static void ansi_set_screen_attribute(char* buffer)
{
while(*buffer)
{
switch(*buffer++)
{
case '0': //Normal
case '1': //Hign Intensity
case '4': //Underscore
case '5': //Blink.
case '7':
case '8':
break;
case '3':
if(*buffer)
buffer++;
break;
case '6':
if(*buffer)
buffer++;
break;
}


if(*buffer && *buffer == ';')
buffer++;
}
}


static void ansi_erase_line(char* buffer)
{
int act = 0;


while(*buffer)
{
act = (*buffer++) - '0';
}
}


static void ansi_set_position(char* buffer)
{
// Grab line
while(*buffer && *buffer != ';')
buffer++;


if(*buffer)
buffer++;

// Grab y
while(*buffer && *buffer != ';')
buffer++;
}


static void ansi_erase_screen(char* buffer)
{
int act = 0;


while(*buffer)
{
act = (*buffer++) - '0';
}
}


static void ansi_move_up(char* buffer)
{
int cnt = *buffer?0:1;


while(*buffer)
{
cnt = cnt*10 + (*buffer++) - '0';
}
}


static int ansi(unsigned char data)
{
int i;
static _ansi_state state = as_normal;


switch( state)
{
case as_normal:
switch(data)
{
case 0:  //eat null codes.
break;
case 27: //ANSI esc.
state = as_esc;
break;
default: //Send all else to the console.
return 1;
}
break;
case as_esc:
state = as_esc1;
codeptr = 0;
codebuf[codeptr] = 0;
break;
case as_esc1:
if(data > 64)
{
codebuf[codeptr] = 0;
for(i=0; codec[i].cmd && codec[i].cmd != data; i++);
if(codec[i].proc)
codec[i].proc(codebuf);
    state = as_normal;
    }
    else
    codebuf[codeptr++] = data;
    break;
  }
  return 0;
}


int TelnetSend( const char* s ) 
{
if(!socketSend(s, strlen(s)))
{
printf( "Could not write to socket.\n" );
return 0;
}

return 1;
}


int TelnetRecv(char* s ) 
{
char buf[40960 + 1];
char *sPtr=buf;
int iRet,i=0;
int ret;


memset(buf,0,sizeof(buf));
    iRet = socketRecv(buf);
ret = iRet;
if (iRet < 0)
{
printf ("TelnetRecv socket error.\n");
return iRet;
}
while(iRet--)
{
if(TelentProtcol(*sPtr))
{
buf[i]=*sPtr;
i++;
}
sPtr++;
}
buf[i]=0;
strncpy(s, buf, 4096);


return ret;
}
/*--------------------------------------------------------------------------------------------*/
#include "Socket.h"
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <arpa/inet.h>


int m_sock_fd = -1;
struct sockaddr_in m_addr;


int is_valid()
{ 
return m_sock_fd != -1;
}


int initSocket()
{
    memset (&m_addr, 0, sizeof(m_addr));
return 1;
}


void sock_client_free()
{
shutdown(m_sock_fd,SHUT_RDWR);
close ( m_sock_fd );
m_sock_fd=-1;
}


int create()
{
int on = 1;
m_sock_fd = socket(AF_INET, SOCK_STREAM, 0);
if (!is_valid())
return 0;

if (setsockopt(m_sock_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof (on)) == -1)
return 0;

return 1;
}


int socketConnect(const char* host, const int port)
{
int ret;
int status;
struct timeval timeout={0, 300000};//3s


if (!is_valid())
return 0;

m_addr.sin_family = AF_INET;
m_addr.sin_port = htons (port);
status = inet_pton (AF_INET, host, &m_addr.sin_addr);

if(errno == EAFNOSUPPORT)
return 0;

ret = setsockopt(m_sock_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
if(-1 == ret)
{
        PDEBUG(L_CRIT, "setsockopt is error!\n");
}

status = connect(m_sock_fd, (struct m_addr *)&m_addr, sizeof(m_addr));
    if (status != 0)
    {
        PDEBUG(L_CRIT, "socket client connect was failed!\n");
        return 0;
    }
    PDEBUG(L_DEBUG, "socket client connect have been successful!\n");
    return 1;
}


int socketSend(const void *buf, size_t len)
{
int status;
status  = send(m_sock_fd, buf, len, MSG_NOSIGNAL);
if (status == -1 && EAGAIN == errno)
    {
return 0;
}


    return status;
}
 
int socketRecv(char *sBuf) 
{
memset(sBuf, 0, 40960);  
return recv(m_sock_fd, sBuf, 40960, 0);
}
/*-----------------------------command.h--------------------------------------------------------*/
// Definition of the Telnet class


#ifndef __COMMAND_H__
#define __COMMAND_H__


int telnet_command_init(void);
int telnet_send_cmd_mesg(const char * command, char * resp);
int command_init(const char *cmd, char *resp);
int parse_cmd_resp_packet(const char *cmd, const char *key, void *store);


#endif /* __COMMAND_H__  */
/*------------------------------socket.h-------------------------------------------------------------------*/
// Definition of the Socket class


#ifndef Socket_class
#define Socket_class


#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <arpa/inet.h>
#include "log.h"


int initSocket();
void sock_client_free();
int create();
int  socketConnect ( const char* host, const int port );
 
int socketSend(const void *buf, size_t len) ;
int socketRecv ( char *sBuf ) ;
int is_valid();
  
#endif
/*--------------------------------telnet.h-----------------------------------------------------------------*/
// Definition of the Telnet class


#ifndef Telnet_class
#define Telnet_class


#include "Socket.h"


typedef  enum 
{
  verb_sb   = 250,
  verb_will = 251,
  verb_wont = 252,
  verb_do   = 253, 
  verb_dont = 254
} _verb;


typedef enum 
{
  state_data,   //we expect a data byte
  state_code,   //we expect a code
  state_option  //we expect an option
} _state;


typedef enum 
{
  TOPT_BIN = 0,   // Binary Transmission
  TOPT_ECHO = 1,  // Echo
  TOPT_RECN = 2,  // Reconnection
  TOPT_SUPP = 3,  // Suppress Go Ahead
  TOPT_APRX = 4,  // Approx Message Size Negotiation
  TOPT_STAT = 5,  // Status
  TOPT_TIM = 6,   // Timing Mark
  TOPT_REM = 7,   // Remote Controlled Trans and Echo
  TOPT_OLW = 8,   // Output Line Width
  TOPT_OPS = 9,   // Output Page Size
  TOPT_OCRD = 10, // Output Carriage-Return Disposition
  TOPT_OHT = 11,  // Output Horizontal Tabstops
  TOPT_OHTD = 12, // Output Horizontal Tab Disposition
  TOPT_OFD = 13,  // Output Formfeed Disposition
  TOPT_OVT = 14,  // Output Vertical Tabstops
  TOPT_OVTD = 15, // Output Vertical Tab Disposition
  TOPT_OLD = 16,  // Output Linefeed Disposition
  TOPT_EXT = 17,  // Extended ASCII
  TOPT_LOGO = 18, // Logout
  TOPT_BYTE = 19, // Byte Macro
  TOPT_DATA = 20, // Data Entry Terminal
  TOPT_SUP = 21,  // SUPDUP
  TOPT_SUPO = 22, // SUPDUP Output
  TOPT_SNDL = 23, // Send Location
  TOPT_TERM = 24, // Terminal Type
  TOPT_EOR = 25,  // End of Record
  TOPT_TACACS = 26, // TACACS User Identification
  TOPT_OM = 27,   // Output Marking
  TOPT_TLN = 28,  // Terminal Location Number
  TOPT_3270 = 29, // Telnet 3270 Regime
  TOPT_X3 = 30,  // X.3 PAD
  TOPT_NAWS = 31, // Negotiate About Window Size
  TOPT_TS = 32,   // Terminal Speed
  TOPT_RFC = 33,  // Remote Flow Control
  TOPT_LINE = 34, // Linemode
  TOPT_XDL = 35,  // X Display Location
  TOPT_ENVIR = 36,// Telnet Environment Option
  TOPT_AUTH = 37, // Telnet Authentication Option
  TOPT_NENVIR = 39,// Telnet Environment Option
  TOPT_EXTOP = 255, // Extended-Options-List
  TOPT_ERROR = 256  // Magic number
} _option;


int telnet_client_init ( const char* host,const int port );
int freeTelnet();
int TelnetSend( const char* s ) ;
int TelnetRecv(char* s );
int TelentProtcol(unsigned char code);


#endif
/*-----------------------------------log.c-------------------------------------------*/
#include "log.h"
#include <stdio.h>
#include <stdarg.h>


void log_message(const char *fname, int line, int priority, const char *format, ...)
{
    va_list vp;
    time_t tv;
    struct tm *t;


    time (&tv);
    t = localtime(&tv);
    flockfile(stdout);
    va_start(vp, format);
    fprintf(stdout, "%d/%d/%d %d:%d:%d[%s: %dL] ",(1900 + t->tm_year), (1 + t->tm_mon), t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, fname, line);
    vfprintf(stdout, format, vp);
    va_end(vp);
    funlockfile(stdout);
}
/*-------------------------------------------log.h------------------------------------------------*/
#define LOG_H


 #include <time.h>


void log_message(const char *fname, int line, int priority, const char *format, ...);
#define PDEBUG(priority, fmt, args...) log_message(__FILE__, __LINE__, priority, fmt, ##args)


enum {
    L_CRIT,
    L_WARNING,
    L_NOTICE,
    L_INFO,
    L_DEBUG
};


#endif // LOG_H
/*------------------------------------------------------------------------------------------------------*/