msica_op.h

Go to the documentation of this file.

/*
 *  openvpnmsica -- Custom Action DLL to provide OpenVPN-specific support to MSI packages
 *                  https://community.openvpn.net/openvpn/wiki/OpenVPNMSICA
 *
 *  Copyright (C) 2018 Simon Rozman <simon@rozman.si>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef MSICA_OP_H
#define MSICA_OP_H

#include <windows.h>
#include <msi.h>
#include <stdarg.h>
#include <stdbool.h>
#include <tchar.h>
#include "../tapctl/basic.h"

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4200) /* Using zero-sized arrays in struct/union. */
#endif


#define MSICA_MAKE_OP_TYPE(op, data)  (((op)<<4)|((data)&0xf))
#define MSICA_OP_TYPE_OP(type)        ((unsigned int)(type)>>4)
#define MSICA_OP_TYPE_DATA(type)      ((unsigned int)(type)&0xf)


enum msica_op_type
{
    msica_op_rollback_enable              = MSICA_MAKE_OP_TYPE(0x1, 0x1),  
    msica_op_tap_interface_create         = MSICA_MAKE_OP_TYPE(0x2, 0x2),  
    msica_op_tap_interface_delete_by_name = MSICA_MAKE_OP_TYPE(0x3, 0x2),  
    msica_op_tap_interface_delete_by_guid = MSICA_MAKE_OP_TYPE(0x3, 0x4),  
    msica_op_tap_interface_set_name       = MSICA_MAKE_OP_TYPE(0x4, 0x5),  
    msica_op_file_delete                  = MSICA_MAKE_OP_TYPE(0x5, 0x2),  
    msica_op_file_move                    = MSICA_MAKE_OP_TYPE(0x6, 0x3),  
};


struct msica_op
{
    enum msica_op_type type;  
    int ticks;                
    struct msica_op *next;    
};


struct msica_op_seq
{
    struct msica_op *head;    
    struct msica_op *tail;    
};


void
msica_op_seq_init(_Inout_ struct msica_op_seq *seq);


void
msica_op_seq_free(_Inout_ struct msica_op_seq *seq);


struct msica_op_bool
{
    struct msica_op base;     
    bool value;               
};


struct msica_op *
msica_op_create_bool(
    _In_ enum msica_op_type type,
    _In_ int ticks,
    _In_opt_ struct msica_op *next,
    _In_ bool value);


struct msica_op_string
{
    struct msica_op base;     
    TCHAR value[];            
};


struct msica_op *
msica_op_create_string(
    _In_ enum msica_op_type type,
    _In_ int ticks,
    _In_opt_ struct msica_op *next,
    _In_z_ LPCTSTR value);


struct msica_op_multistring
{
    struct msica_op base;     
    TCHAR value[];            
};


struct msica_op *
msica_op_create_multistring_va(
    _In_ enum msica_op_type type,
    _In_ int ticks,
    _In_opt_ struct msica_op *next,
    _In_ va_list arglist);


struct msica_op_guid
{
    struct msica_op base;     
    GUID value;               
};


struct msica_op *
msica_op_create_guid(
    _In_ enum msica_op_type type,
    _In_ int ticks,
    _In_opt_ struct msica_op *next,
    _In_ const GUID *value);


struct msica_op_guid_string
{
    struct msica_op base;     
    GUID value_guid;          
    TCHAR value_str[];        
};


struct msica_op *
msica_op_create_guid_string(
    _In_ enum msica_op_type type,
    _In_ int ticks,
    _In_opt_ struct msica_op *next,
    _In_ const GUID *value_guid,
    _In_z_ LPCTSTR value_str);


static inline struct msica_op *
msica_op_create_multistring(
    _In_ enum msica_op_type type,
    _In_ int ticks,
    _In_opt_ struct msica_op *next,
    ...)
{
    va_list arglist;
    va_start(arglist, next);
    struct msica_op *op = msica_op_create_multistring_va(type, ticks, next, arglist);
    va_end(arglist);
    return op;
}


static inline bool
msica_op_seq_is_empty(_In_ const struct msica_op_seq *seq)
{
    return seq->head != NULL;
}


void
msica_op_seq_add_head(
    _Inout_ struct msica_op_seq *seq,
    _Inout_ struct msica_op *operation);


void
msica_op_seq_add_tail(
    _Inout_ struct msica_op_seq *seq,
    _Inout_ struct msica_op *operation);


DWORD
msica_op_seq_save(
    _In_ const struct msica_op_seq *seq,
    _In_ HANDLE hFile);


DWORD
msica_op_seq_load(
    _Inout_ struct msica_op_seq *seq,
    _In_ HANDLE hFile);


#define MSICA_CLEANUP_ACTION_COMMIT   0
#define MSICA_CLEANUP_ACTION_ROLLBACK 1
#define MSICA_CLEANUP_ACTION_COUNT    2


struct msica_session
{
    MSIHANDLE hInstall;           
    bool continue_on_error;       
    bool rollback_enabled;        
    struct msica_op_seq seq_cleanup[MSICA_CLEANUP_ACTION_COUNT]; 
};


void
openvpnmsica_session_init(
    _Inout_ struct msica_session *session,
    _In_ MSIHANDLE hInstall,
    _In_ bool continue_on_error,
    _In_ bool rollback_enabled);


DWORD
msica_op_seq_process(
    _Inout_ const struct msica_op_seq *seq,
    _Inout_ struct msica_session *session);

#ifdef _MSC_VER
#pragma warning(pop)
#endif

#endif /* ifndef MSICA_OP_H */