/*++

Copyright (c) 1992-1996  Microsoft Corporation

Module Name:

    sess_lm.c

Abstract:

    This file contains MIB_sess_lmget, which actually call lan manager
    for the session table, copies it into structures, and sorts it to
    return ready to use by the higher level functions.

Environment:

    User Mode - Win32

Revision History:

    10-May-1996 DonRyan
        Removed banner from Technology Dynamics, Inc.

--*/
 
//--------------------------- WINDOWS DEPENDENCIES --------------------------

//--------------------------- STANDARD DEPENDENCIES -- #include<xxxxx.h> ----

#ifdef WIN32
#include <windows.h>
#include <lm.h>
#endif

#include <tchar.h>
#include <string.h>
#include <search.h>
#include <stdlib.h>
#include <time.h>

//--------------------------- MODULE DEPENDENCIES -- #include"xxxxx.h" ------


#include "mib.h"
#include "mibfuncs.h"
#include "sess_tbl.h"
#include "lmcache.h"

//--------------------------- SELF-DEPENDENCY -- ONE #include"module.h" -----

//--------------------------- PUBLIC VARIABLES --(same as in module.h file)--

//--------------------------- PRIVATE CONSTANTS -----------------------------

#define SafeBufferFree(x)       if(NULL != x) NetApiBufferFree( x )
#define SafeFree(x)             if(NULL != x) SnmpUtilMemFree( x )

//--------------------------- PRIVATE STRUCTS -------------------------------

//--------------------------- PRIVATE VARIABLES -----------------------------

//--------------------------- PRIVATE PROTOTYPES ----------------------------

int __cdecl sess_entry_cmp(
       IN const SESS_ENTRY *A,
       IN const SESS_ENTRY *B
       ) ;

BOOL build_sess_entry_oids( );

void FreeSessTable();

//--------------------------- PRIVATE PROCEDURES ----------------------------

//--------------------------- PUBLIC PROCEDURES -----------------------------

//
// MIB_sess_lmset
//    Perform the necessary actions to SET a field in the Session Table.
//
// Notes:
//
// Return Codes:
//
// Error Codes:
//    None.
//
UINT MIB_sess_lmset(
        IN AsnObjectIdentifier *Index,
        IN UINT Field,
        IN AsnAny *Value
        )

{
NET_API_STATUS lmCode;
int            Found;
UINT           Entry;
AsnInteger     ErrStat = SNMP_ERRORSTATUS_NOERROR;
char           Client[MAX_PATH];
char           User[MAX_PATH];
#ifdef UNICODE
LPWSTR         UniClient;
LPWSTR         UniUser;
#endif


   // Must make sure the table is in memory
   if ( SNMPAPI_ERROR == MIB_sess_lmget() )
      {
      ErrStat = SNMP_ERRORSTATUS_GENERR;
      goto Exit;
      }

   // Find a match in the table
   if ( MIB_TBL_POS_FOUND != MIB_sess_match(Index, &Entry, FALSE) )
      {
      ErrStat = SNMP_ERRORSTATUS_NOSUCHNAME;
      goto Exit;
      }

   // Check for action on Table
   if ( Value->asnValue.number == SESS_STATE_DELETED )
      {
      strcpy( Client, "\\\\" );
      if (MIB_SessionTable.Table[Entry].svSesClientName.length <= MAX_PATH-3)
        {
        memcpy( &Client[2], MIB_SessionTable.Table[Entry].svSesClientName.stream,
                       MIB_SessionTable.Table[Entry].svSesClientName.length );
        Client[MIB_SessionTable.Table[Entry].svSesClientName.length+2] = '\0';
        }
      else
        {
        ErrStat = SNMP_ERRORSTATUS_GENERR;
        goto Exit;
        }

      if (MIB_SessionTable.Table[Entry].svSesUserName.length <= MAX_PATH-1)
        {
        memcpy( User, MIB_SessionTable.Table[Entry].svSesUserName.stream,
                    MIB_SessionTable.Table[Entry].svSesUserName.length );
        User[MIB_SessionTable.Table[Entry].svSesUserName.length] = '\0';
        }
      else
        {
        ErrStat = SNMP_ERRORSTATUS_GENERR;
        goto Exit;
        }


#ifdef UNICODE
      if (SnmpUtilUTF8ToUnicode(&UniClient,
                                Client,
                                TRUE ))
      {
          ErrStat = SNMP_ERRORSTATUS_RESOURCEUNAVAILABLE;
          goto Exit;
      }
      if (SnmpUtilUTF8ToUnicode(&UniUser,
                                User,
                                TRUE ))
      {
          SnmpUtilMemFree(UniClient);
          ErrStat = SNMP_ERRORSTATUS_RESOURCEUNAVAILABLE;
          goto Exit;
      }

      lmCode = NetSessionDel( NULL, UniClient, UniUser );
      SnmpUtilMemFree(UniClient);
      SnmpUtilMemFree(UniUser);
#else
      // Call the LM API to delete it
      lmCode = NetSessionDel( NULL, Client, User );
#endif

      // Check for successful operation
      switch( lmCode )
         {
         case NERR_Success:
            // Make cache be reloaded next time
            cache_table[C_SESS_TABLE].bufptr = NULL;
            break;

         case NERR_ClientNameNotFound:
         case NERR_UserNotFound:
            ErrStat = SNMP_ERRORSTATUS_NOSUCHNAME;
            break;

         default:
            ErrStat = SNMP_ERRORSTATUS_GENERR;
         }
      }

Exit:
   return ErrStat;
} // MIB_sess_lmset



//
// MIB_sess_lmget
//    Retrieve session table information from Lan Manager.
//    If not cached, sort it and then
//    cache it.
//
// Notes:
//
// Return Codes:
//    SNMPAPI_NOERROR
//    SNMPAPI_ERROR
//
// Error Codes:
//    None.
//
SNMPAPI MIB_sess_lmget(
           )

{

DWORD entriesread;
DWORD totalentries;
LPBYTE bufptr=NULL;
unsigned lmCode;
unsigned i;
SESSION_INFO_2 *DataTable;
SESS_ENTRY *MIB_SessionTableElement ;
int First_of_this_block;
time_t curr_time ;
SNMPAPI nResult = SNMPAPI_NOERROR;
LPSTR tempbuff = NULL;
DWORD resumehandle=0;
DWORD dwAllocatedEntries=0;

   time(&curr_time);    // get the time


//return nResult;  // OPENISSUE  remember the problem with the error
                 // every time a free is done from this call to Enum?


   //
   //
   // If cached, return piece of info.
   //
   //


   if((NULL != cache_table[C_SESS_TABLE].bufptr) &&
      (curr_time <
        (cache_table[C_SESS_TABLE].acquisition_time
                 + cache_expire[C_SESS_TABLE]              ) ) )
        { // it has NOT expired!

        goto Exit ; // the global table is valid

        }

   //
   //
   // Do network call to gather information and put it in a nice array
   //
   //

   // free the old table  LOOK OUT!!
    FreeSessTable();


   First_of_this_block = 0;

   do {  //  as long as there is more data to process

   lmCode =
   NetSessionEnum( NULL,                        // local server
                        NULL,           // get server stats
                        NULL,
                        2,                      // level
                        &bufptr,                // data structure to return
                        MAX_PREFERRED_LENGTH,
                        &entriesread,
                        &totalentries,
                        NULL   //&resumehandle          //  resume handle
                        );


    if(NULL == bufptr)  return nResult ;

    DataTable = (SESSION_INFO_2 *) bufptr ;

    if((NERR_Success == lmCode) || (ERROR_MORE_DATA == lmCode))
        {  // valid so process it, otherwise error

        if(0 == MIB_SessionTable.Len) {  // 1st time, alloc the whole table
                // alloc the table space
                MIB_SessionTable.Table = SnmpUtilMemAlloc(totalentries *
                                                sizeof(SESS_ENTRY) );
                if (NULL == MIB_SessionTable.Table)
                {
                    // free all of the lan man data
                    SafeBufferFree( bufptr );
                    nResult = SNMPAPI_ERROR;
                    goto Exit;
                }
                dwAllocatedEntries = totalentries;
        }

        MIB_SessionTableElement = MIB_SessionTable.Table + First_of_this_block ;

        for(i=0; (i<entriesread) && ((i+First_of_this_block) < dwAllocatedEntries); i++) {  // once for each entry in the buffer
                // increment the entry number

                MIB_SessionTable.Len ++;

                // Stuff the data into each item in the table

                // client name
                MIB_SessionTableElement->svSesClientName.dynamic = TRUE;

#ifdef UNICODE
                if (SnmpUtilUnicodeToUTF8(
                        &MIB_SessionTableElement->svSesClientName.stream,
                        DataTable->sesi2_cname,
                        TRUE))
                {
                    MIB_SessionTableElement->svSesClientName.stream = NULL;
                    MIB_SessionTableElement->svSesClientName.length = 0;
                    MIB_SessionTableElement->svSesClientName.dynamic = FALSE;
                }
                else
                {
                    MIB_SessionTableElement->svSesClientName.length = 
                        strlen (MIB_SessionTableElement->svSesClientName.stream);
                }
#else
                MIB_SessionTableElement->svSesClientName.stream = SnmpUtilMemAlloc (
                                strlen( DataTable->sesi2_cname )+1 ) ;
                MIB_SessionTableElement->svSesClientName.length =
                                strlen( DataTable->sesi2_cname ) ;
                memcpy( MIB_SessionTableElement->svSesClientName.stream,
                        DataTable->sesi2_cname,
                        strlen( DataTable->sesi2_cname ) ) ;
#endif

                // user name
                MIB_SessionTableElement->svSesUserName.dynamic = TRUE;


#ifdef UNICODE
                if (SnmpUtilUnicodeToUTF8(
                        &MIB_SessionTableElement->svSesUserName.stream,
                        DataTable->sesi2_username,
                        TRUE))
                {
                    MIB_SessionTableElement->svSesUserName.length = 0;
                    MIB_SessionTableElement->svSesUserName.stream = NULL;
                    MIB_SessionTableElement->svSesUserName.dynamic = FALSE;
                }
                else
                {
                    MIB_SessionTableElement->svSesUserName.length =
                        strlen(MIB_SessionTableElement->svSesUserName.stream);
                }
#else
                MIB_SessionTableElement->svSesUserName.stream = SnmpUtilMemAlloc (
                    strlen( DataTable->sesi2_username ) + 1 ) ;
                MIB_SessionTableElement->svSesUserName.length =
                    strlen( DataTable->sesi2_username ) ;

                memcpy( MIB_SessionTableElement->svSesUserName.stream,
                        DataTable->sesi2_username,
                        strlen( DataTable->sesi2_username ) ) ;
#endif
                // number of connections
                MIB_SessionTableElement->svSesNumConns =
                        // DataTable->sesi2_num_conns ; LM_NOT_THERE
                        0 ;  // so get ready in case somebody implements

                // number of opens
                MIB_SessionTableElement->svSesNumOpens =
                        DataTable->sesi2_num_opens ;

                // session time
                MIB_SessionTableElement->svSesTime =
                        DataTable->sesi2_time ;

                // session idle time
                MIB_SessionTableElement->svSesIdleTime =
                        DataTable->sesi2_idle_time ;

                // client type parsing

                // first convert from unicode if needed
#ifdef UNICODE
                if (SnmpUtilUnicodeToUTF8(
                        &tempbuff,
                        DataTable->sesi2_cltype_name,
                        TRUE))
                {
                    MIB_SessionTableElement->svSesClientType = 0 ;
                }
                else
                {
#else
                tempbuff = SnmpUtilMemAlloc( strlen(DataTable->sesi2_cltype_name) + 1 );
                memcpy( tempbuff,
                        DataTable->sesi2_cltype_name,
                        strlen( DataTable->sesi2_cltype_name ) ) ;
#endif

                // let's assume 0 is undefined but better than garbage ...
                MIB_SessionTableElement->svSesClientType = 0 ;
                if(0==strcmp(   "DOWN LEVEL",
                                tempbuff))
                        MIB_SessionTableElement->svSesClientType = 1 ;
                else if(0==strcmp("DOS LM",
                                  tempbuff))
                        MIB_SessionTableElement->svSesClientType = 2 ;
                else if(0==strcmp("DOS LM 2.0",
                                  tempbuff))
                        MIB_SessionTableElement->svSesClientType = 3 ;
                else if(0==strcmp("OS/2 LM 1.0",
                                  tempbuff))
                        MIB_SessionTableElement->svSesClientType = 4 ;
                else if(0==strcmp("OS/2 LM 2.0",
                                  tempbuff))
                        MIB_SessionTableElement->svSesClientType = 5 ;
                else if(0==strcmp("DOS LM 2.1",
                                  tempbuff))
                        MIB_SessionTableElement->svSesClientType = 6 ;
                else if(0==strcmp("OS/2 LM 2.1",
                                  tempbuff))
                        MIB_SessionTableElement->svSesClientType = 7 ;
                else if(0==strcmp("AFP 1.1",
                                  tempbuff))
                        MIB_SessionTableElement->svSesClientType = 8 ;
                else if(0==strcmp("AFP 2.0",
                                  tempbuff))
                        MIB_SessionTableElement->svSesClientType = 9 ;
                else if(0==strcmp("NT",
                                  tempbuff))
                        MIB_SessionTableElement->svSesClientType = 10 ;
                SnmpUtilMemFree(tempbuff);
                tempbuff = NULL;
#ifdef UNICODE
                }
#endif

                // state is always active, set uses to indicate delete request
                MIB_SessionTableElement->svSesState = 1; //always active


                DataTable ++ ;  // advance pointer to next sess entry in buffer
                MIB_SessionTableElement ++ ;  // and table entry

        } // for each entry in the data table


        // free all of the lan man data
        SafeBufferFree( bufptr ) ;

        // indicate where to start adding on next pass, if any
        First_of_this_block += i ;

        } // if data is valid to process
    else
       {
       // Signal error
       nResult = SNMPAPI_ERROR;
       goto Exit;
       }

    } while (ERROR_MORE_DATA == lmCode) ;

    // iterate over the table populating the Oid field
    if (! build_sess_entry_oids())
    {
        SNMPDBG((
            SNMP_LOG_TRACE,
            "SNMP: LMMIB2: build_sess_entry_oids failed\n."));

        FreeSessTable();
        cache_table[C_SESS_TABLE].bufptr = NULL;
        nResult = SNMPAPI_ERROR;
        goto Exit;
    }

   // Sort the table information using MSC QuickSort routine
   qsort( (void *)&MIB_SessionTable.Table[0], (size_t)MIB_SessionTable.Len,
          (size_t)sizeof(SESS_ENTRY), sess_entry_cmp );

   //
   //
   // Cache table
   //
   //

   if(0 != MIB_SessionTable.Len) {

        cache_table[C_SESS_TABLE].acquisition_time = curr_time ;

        cache_table[C_SESS_TABLE].bufptr = bufptr ;
   }


   //
   //
   // Return piece of information requested
   //
   //

Exit:
   return nResult;
} // MIB_sess_get

//
// MIB_sess_cmp
//    Routine for sorting the session table.
//
// Notes:
//
// Return Codes:
//    SNMPAPI_NOERROR
//    SNMPAPI_ERROR
//
// Error Codes:
//    None.
//
int __cdecl sess_entry_cmp(
       IN const SESS_ENTRY *A,
       IN const SESS_ENTRY *B
       )

{
   // Compare the OID's
   return SnmpUtilOidCmp( (AsnObjectIdentifier *)&A->Oid,
                       (AsnObjectIdentifier *)&B->Oid );
} // MIB_sess_cmp


//
//    None.
//
BOOL build_sess_entry_oids(
       )

{
    AsnOctetString OSA ;
    AsnObjectIdentifier UserNameOid ;
    SESS_ENTRY *SessEntry ;
    unsigned i;

    // start pointer at 1st guy in the table
    SessEntry = MIB_SessionTable.Table ;

    // now iterate over the table, creating an oid for each entry
    for( i=0; i<MIB_SessionTable.Len ; i++)  {
        // for each entry in the session table

        // copy the client name into the oid buffer first
        if (! MakeOidFromStr( &SessEntry->svSesClientName, &SessEntry->Oid ))
        {
            return FALSE;
        }

        // copy the user name into a temporary oid buffer
        if (! MakeOidFromStr( &SessEntry->svSesUserName, &UserNameOid ))
        {
            return FALSE;
        }

        // append the two entries forming the index
        if (! SnmpUtilOidAppend( &SessEntry->Oid, &UserNameOid ))
        {
            SnmpUtilOidFree( &UserNameOid );
            return FALSE;
        }

        // free the temporary buffer
        SnmpUtilOidFree( &UserNameOid );

        SessEntry++; // point to the next guy in the table

    } // for
    return TRUE;

} // build_sess_entry_oids

void FreeSessTable()
{
    UINT i;
    SESS_ENTRY *MIB_SessionTableElement ;

    MIB_SessionTableElement = MIB_SessionTable.Table ;

    if (MIB_SessionTableElement)
    {
        // iterate over the whole table
        for(i=0; i<MIB_SessionTable.Len ;i++)
        {
            // free any alloc'ed elements of the structure
            SnmpUtilOidFree(&(MIB_SessionTableElement->Oid));
            SnmpUtilMemFree(MIB_SessionTableElement->svSesClientName.stream);
            SnmpUtilMemFree(MIB_SessionTableElement->svSesUserName.stream);

            MIB_SessionTableElement ++ ;  // increment table entry
        }
        SnmpUtilMemFree(MIB_SessionTable.Table) ; // free the base Table
    }
    MIB_SessionTable.Table = NULL ;    // just for safety
    MIB_SessionTable.Len = 0 ;         // just for safety
}
//-------------------------------- END --------------------------------------