// /*******************************************************************
//  * ********************************************************************
//  * ****                                                              **
//  * ****    (C)Copyright 2008-2009, American Megatrends Inc.          **
//  * ****                                                              **
//  * ****    All Rights Reserved.                                      **
//  * ****                                                              **
//  * ****    5555 , Oakbrook Pkwy, Norcross,                           **
//  * ****                                                              **
//  * ****    Georgia - 30093, USA. Phone-(770)-246-8600.               **
//  * ****                                                              **
//  * ********************************************************************
//  * ********************************************************************
//  * ********************************************************************
//  * **
//  * ** libipmi_uds_session.c
//  * ** Unix Domain Socket library file
//  * **
//  * ** Author: Suresh V (sureshv@amiindia.co.in)
//  * *******************************************************************/
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <sys/types.h>
// #include <sys/socket.h>
// #include <sys/un.h>
// #include <unistd.h>
// //#include <netinet/in.h>
// //#include <arpa/inet.h>
// #include <sys/time.h>
// #include <sys/select.h>
// #include <sys/file.h>
// #include <fcntl.h>
// #include <errno.h>
// #include "libipmi_session.h"
// #include "libipmi_errorcodes.h"
// #include "com_IPMIDefs.h"
// #include "com_IPMI_AppDevice.h"
// #include "com_IPMI_IPM.h"
// #include "com_IPMI_App.h"
// #include <sys/syscall.h>
// #define gettid()  syscall(SYS_gettid)


// // /*This Functions Fills the Packet
// //  * with the valid fields for UDS*/
// // uint32_t FillUDSMessagePacket(IPMI20_UDS_SESSION_T *pUDSSession, uint8_t *Buffer,
// //                         uint8_t byNetFnLUN, uint8_t byCommand,
// //                         uint8_t *pbyReqData, uint32_t dwReqDataLen)
// // {
// //     uint8_t *pbyIPMIUDSData;
// //     IPMIUDSMsg_T *pUDSMsg;
// //     pUDSMsg = (IPMIUDSMsg_T *)&Buffer[0];
// //     pbyIPMIUDSData = &Buffer[sizeof(IPMIUDSMsg_T)];

// //     pUDSMsg->SessionID = pUDSSession->dwSessionID;
// //     pUDSMsg->ChannelNum = pUDSSession->byChannelNum;
// //     //pUDSMsg->Privilege = pUDSSession->byRole;
// //     pUDSMsg->IPMIMsgLen = sizeof(IPMIUDSMsg_T)+dwReqDataLen+1;
// //     pUDSMsg->Cmd = byCommand;
// //     pUDSMsg->NetFnLUN = byNetFnLUN;

// //     //memcpy(pUDSMsg->UserName, pUDSSession->szUName, MAX_USERNAME_LEN);
// //     //memcpy(pUDSMsg->IPAddr, pUDSSession->abyIPAddr, IP6_ADDR_LEN);
// //     //pUDSMsg->ProcessID = getpid();
// //     //pUDSMsg->ThreadID = gettid();
// //     memcpy(pbyIPMIUDSData, pbyReqData, dwReqDataLen);

// //     return ( sizeof(IPMIUDSMsg_T) + dwReqDataLen + 1);
// // }

// /*This Function is used to recieve
//   data from UDS Interface as response*/
// uint8_t UDS_ReceiveData( UDS_CHANNEL_T *UDSInfo, char *szBuffer, uint32_t* pdwSize, int timeout )
// {
//     struct timeval wait_time, *pwait_time;
//     fd_set rdfs;
//     int nDes = 0,totalrecvd = 0,ret = 0;
//     IPMIUDSMsg_T *pData = (IPMIUDSMsg_T *)szBuffer;
//     uint32_t nBytesRecvd = 0;

//     /* Wait for the socket to get ready */
//     if(timeout >= 0)
//     {
//         wait_time.tv_sec = timeout;
//         wait_time.tv_usec = 0;
//         pwait_time = &wait_time;
//     }
//     else
//         pwait_time = NULL;

//     FD_ZERO(&rdfs);
//     FD_SET(UDSInfo->hSocket, &rdfs);
//     nDes = UDSInfo->hSocket + 1;

//     while(1)
//     {
//         /* wait for specified amount of time */
//         ret = select (nDes, &rdfs, NULL, NULL, pwait_time);
//         /* socket error */
//         if(ret == -1)
//         {
//             if(errno == EINTR)
//             {
//                 printf("select: %s. Continue...\n",strerror(errno));
//                 continue;
//             }
//             else
//             {
//                 printf("select failed while waiting for read pipe \n");
//                 continue;
//             }
//         }
//         else if(ret == 0)
//         {
//               printf("Connection timed out\n");
//               return LIBIPMI_MEDIUM_E_TIMED_OUT;
//          }

//         /* socket is ready to receive data */
//         if(FD_ISSET(UDSInfo->hSocket,&rdfs))
//          {
//             nBytesRecvd = recv(UDSInfo->hSocket,szBuffer+totalrecvd,MAX_RESPONSE_SIZE,0);
//             if(nBytesRecvd == 0)
//             {
//                 printf("End of File Encountered ... may be socket closure\n");
//                 close(UDSInfo->hSocket);
//                 return LIBIPMI_MEDIUM_E_RECV_DATA_FAILURE;
//             }
//             if(nBytesRecvd == -1)
//             {
//                 printf("Socket Error... may be socket closure\n");
//                 close(UDSInfo->hSocket);
//                 return LIBIPMI_MEDIUM_E_RECV_DATA_FAILURE;
//             }

//             // int i;
//             // printf("---> client recv %#x: ", nBytesRecvd);
//             // for(i=0;i<nBytesRecvd;i++)
//             //     printf("%#x ", szBuffer[totalrecvd+i]);
//             // printf("\n");

//             totalrecvd += nBytesRecvd;

//             if(totalrecvd < sizeof(IPMIUDSMsg_T))
//             {
//               continue;
//             }

//             while(totalrecvd < pData->IPMIMsgLen)
//             {
//               continue;
//             }
//         return LIBIPMI_STATUS_SUCCESS;
//        }

//        return LIBIPMI_MEDIUM_E_RECV_DATA_FAILURE; 
//      }
// }


// /*This Function is used to send the
//  * data to UDS Interface*/
// int UDS_SendData(UDS_CHANNEL_T *UDSInfo,char *szBuffer,uint32_t dwsize,int timeout)
// {
//     int nTotalBytesSent = 0, nBytesSent = 0;
//     struct timeval wait_time, *pwait_time;
//     fd_set wdfs;
//     int ret;
//    int nDes;

//     /* Wait for the socket to get ready */
//     if(timeout >= 0)
//     {
//         wait_time.tv_sec = timeout;
//         wait_time.tv_usec = 0;
//         pwait_time = &wait_time;
//     }
//     else
//         pwait_time = NULL;

//     FD_ZERO(&wdfs);
//     FD_SET(UDSInfo->hSocket, &wdfs);
//     nDes = UDSInfo->hSocket + 1;

// TCPSendUDSDataSelect:
//     /* wait for specified amount of time */
//     ret = select (nDes, NULL, &wdfs, NULL, pwait_time);
//     /* socket error */
//     if(ret == -1)
//     {
//         if(errno == EINTR)
//         {
//             printf("select: %s. Continue...\n",strerror(errno));
//             goto TCPSendUDSDataSelect;
//         }
//         else
//         {
//             printf("Select failed while waiting for write pipe \n");
//             close(UDSInfo->hSocket);
//             return LIBIPMI_MEDIUM_E_INVALID_SOCKET;
//         }
//     }
//     /* timed out */
//     else if(ret == 0)
//     {
//         printf("Connection timedout: Write Pipe is full \n");
//         close(UDSInfo->hSocket);
//         return LIBIPMI_MEDIUM_E_TIMED_OUT_ON_SEND;
//     }

//    if(FD_ISSET(UDSInfo->hSocket,&wdfs))
//     {
//         /* socket is ready to send data */
//         nTotalBytesSent = 0;

//         /* Till the last byte is sent */
//         while( nTotalBytesSent < (int)dwsize )
//         {
//             /* send data */
            
//             nBytesSent = send (UDSInfo->hSocket,szBuffer+nTotalBytesSent,dwsize, MSG_NOSIGNAL);
            
//             int i=0;
//             // printf("---> client Send %#x: ",  nBytesSent);
//             // for (i = 0; i < nBytesSent; ++i)
//             // {
//             //     printf("%#x ", szBuffer[nTotalBytesSent+i]);
//             // }
//             // printf("\n");

//             /* send failure */
//             if ((nBytesSent == -1) && ((EBADF == errno) || (EPIPE == errno)))
//             {
//                 printf("Error while sending data \n");
//                 close(UDSInfo->hSocket);
//                 return LIBIPMI_MEDIUM_E_SEND_DATA_FAILURE;
//             }
//             else
//             {
//                 nTotalBytesSent += nBytesSent;
//                 dwsize -= nTotalBytesSent;
//             }
//         }
//         return LIBIPMI_STATUS_SUCCESS;

//     }
//     return LIBIPMI_MEDIUM_E_SEND_DATA_FAILURE;
//  }

