现在位置: 首页 / 文档 / word / 正文

从word工具栏中启动应用程序

  • bill
  • 文档
  • 2024-07-15
  • 104热度
  • 0评论

下面是小编收集整理的从word工具栏中启动应用程序，本文共5篇，供大家参考借鉴，欢迎大家分享。

从word工具栏中启动应用程序

以下操作在Word 和Word 中通过，

单击Word“工具”菜单下的“自定义”命令，打开“自定义”对话框，在常用工具栏上“插入超链接”按钮上右击鼠标，在弹出的菜单中执行“分配超链接”下的“打开”命令，打开“分配超链接”对话框，通过“查找范围”右侧的下拉按钮，找到计算器程序文件CALC.EXE(通常位于C:Windows目录中)，“确定”退出，关闭“自定义”对话框。以后需要调用“计算器”时，单击工具栏上“插入超链接”按钮，弹出一个安全警示对话框，不必管它，按“确定”按钮，即可启动“计算器”程序。对于其他一些按钮，您也可以按需要作出相应的设置，

在使用“分配超链接”时注意以下几点：

1. 给按钮分配了超链接后，在单击该按钮后只会直接打开它所链接的应用程序，但不会对执行菜单命令或按下快捷键产生影响。如经过上述操作后，可通过按下“Ctrl+K”键或选择“插入”下的“超链接”命令，打开原来的“插入超链接”对话框。所以在实际使用时最好选择那些快捷键很熟悉的按钮来进行分配。

2. 要想改变或恢复原来的按钮功能，可以再次打开“自定义”对话框，然后右击该按钮，选择“分配超链接”下的“打开(或删除链接)”命令，可以重新分配(或删除)该按钮的超链接。

3. 分配的超链接对象可以是应用程序，也可以是文件夹或具体文件。如果是文件夹，按下按钮后会快速定位到该文件夹，这对于快速打开其中的文件很方便;如果是具体文件，就会调用相应的关联程序打开该文件。

4. 对于在文档中经常需要插入的特定图片，可以通过执行“分配超链接”下的“插入图片”命令，来实现图片的快速插入。

在 VB 应用程序中控制Win95的启动 ---- 在 用Visual Basic 编 写Win95 应 用 程 序 时， 有 时 可 能 希 望 由 程 序 来 控 制 计 算 机 的 启 动 功 能， 比 如 当 应 用 程 序 对 系 统 注 册 表 作 了 修 改 后 需 要 重 新 启 动Win95， ---- 那 么， 如

在VB应用程序中控制Win95的启动

---- 在 用Visual Basic 编 写Win95 应 用 程 序 时， 有 时 可 能 希 望 由 程 序 来 控 制 计 算 机 的 启 动 功 能， 比 如 当 应 用 程 序 对 系 统 注 册 表 作 了 修 改 后 需 要 重 新 启 动Win95。

---- 那 么， 如 何 在 应 用 程 序 中 控 制Win95 的 启 动 呢 ？ 由 于Visual Basic 自 身 没 有 提 供 相 关 的 命 令 和 函 数， 我 们 只 好 求 助 于Windows API 函 数ExitWindowsEx， 调 用 该 函 数， 我 们 可 以 完 成 重 新 启 动、关 机、强 制 关 闭 所 有 应 用 程 序 或 重 新 登 录 等 操 作， 下 面 是 该 函 数 的 函 数 声 明：

Declare Function ExitWindowsEx Lib

“user32” (ByVal uFlags As Long,

ByVal dwReserved As Long) As Long

---- ExitWindowsEx 函 数 有 两 个 参 数， 其 中 第 二 个 为 保 留 参 数， 第 一 个 参 数uFlags 用 来 决 定 调 用 函 数 时 的 具 体 动 作， 可 能 的 取 值 和 含 义 见 下 表：

U flags的值含义

0 重新登录

1 关闭计算机

2 重新启动

4 强制关闭所有应用程序

---- 下 面 以 一 个 小 程 序 为 例， 介 绍 如 何 在 程 序 中 控 制Win95 的 启 动：

---- 新 建 一 个 工 程， 添 加 一 个 普 通 窗 体Form1， 在 窗 体 上 放 置 一 个Frame. 控 件Frame1、一 个 命 令 按 钮 控 件Command1 和 一 个 包 含4 个 元 素 的 选 项 按 钮 控 件 数 组Option1，

再 给 工 程 添 加 一 个 代 码 模 块Module1， 在 其

---- 中 写 上 如 下 的 声 明（ 注 意ExitWindowsEx 的 函 数 声 明 必 须 写 在 一 行 上）：

Public Const LOGOFF = 0

Public Const SHUTDOWN = 1

Public Const REBOOT = 2

Public Const CLOSEPROGRAMES = 4

Declare Function ExitWindowsEx Lib “user32”

(ByVal uFlags As Long, ByVal dwReserved As Long) As Long

在窗体Form1的代码模块中编写

Command1的Click事件过程如下：

Private Sub Command1_Click

Dim How As Long

If Option1(0).Value = True Then

How = LOGOFF 注释：选择了重新登录

ElseIf Option1(1).Value = True Then

How = REBOOT 注释：选择了重新启动

ElseIf Option1(2).Value = True Then

How = SHUTDOWN 注释：选择了关闭计算机

Else

How = CLOSEPROGRAMES 注释：选择了关闭所有程序

End If

Call ExitWindowsEx(How, 0) 注释：执行操作

End Sub

---- 按 下F5， 运 行 本 程 序， 选 择 某 个 功 能， 然 后 按 下 确 认 按 钮， 嘿 ！ 不 错 吧。 本 程 序 用Visual Basic 5.0 编 写， 在Pwin95 和Pwin97 环 境 下 运 行 正 常。

原文转自：www.ltesting.net

这篇文章主要介绍了CMD命令行中以管理员权限启动应用程序实现方法,本文使用一个JS脚本来实现,需要的朋友可以参考下

自从Vista带来了UAC之后，应用程序就变成了两种，有管理员权限的，和没有管理员权限的，一些老的应用程序会莫名其妙地出错，这时候就要考虑右击应用程序，然后“以管理员身份运行”。这还不是什么大问题，exe文件的右键菜单里都会有这个，但是对于一些脚本文件(cmd, js一类）来说，就没那么方便了。通常需要重新开一个带管理员权限的命令行窗口，然后打很多cd回到刚的文件夹，然后再运行脚本，相当麻烦。

搜了一下，找到一个解决办法。把下面的代码保存为Elevate.js：

var command = WScript.Arguments.Item(0);var argument = “”;for (var i = 0; i

以后要以管理员身份运行程序的时候，只要输入“Elevate ”就可以了，比如“Elevate cmd /k”，

当然，这个逃不过UAC的检查，还是会有一个对话框弹出来要点“确定”的。

作者：Idle_ (阿呆)  来源：CSND

windows似乎只提供了一种启动进程的方法：即必须从一个可执行文件中加载并启动，

而下面这段代码就是提供一种可以直接从内存中启动一个exe的变通办法。

用途嘛, 也许可以用来保护你的exe，你可以对要保护的 exe 进行任意切分、加密、存储，只要运行时能将exe的内容正确拼接到一块内存中，就可以直接从内存中启动，而不必不安全地去生成一个临时文件再从临时文件启动进程。另外这段代码也提供了一种自己写exe外壳的简单途径，如果能配合其它各种外壳技术就更好地保护你的exe文件。

原理很简单：就是“借尸还魂”，启动一个僵尸进程（NT下可以是自身程序启动的另一个进程），然后在它运行前将其整个替换成内存中的exe内容，待正式运行后执行的就是你的目标代码了。

不过代码中还有一些不尽人意的地方，比如在98下运行会留一个僵尸程序的壳在硬盘上（其实那个僵尸程序本身就是一个完整的可执行程序，直接运行的话只显示一条错误信息然后就退出了）。另外由于客观条件限制，代码没有经过充分测试，只在XP下进行了一些初步测试：普通exe都能正常运行，upx压缩过的exe绝大多数情况下都能运行，只有在不能卸载僵尸外壳时才有问题（upx压缩过的exe没有重定向表，无法加载到其它地址运行）。

如果有bug望告之，如果有更好的方法特别是能解决98下的遗留尾巴的话希望不吝赐教。

{ ******************************************************* }

{ *                从内存中加载并运行exe              * }

{ ******************************************************* }

{ * 参数：                                               }

{ * Buffer: 内存中的exe地址                              }

{ * Len: 内存中exe占用长度                               }

{ * CmdParam: 命令行参数(不包含exe文件名的剩余命令行参数）}

{ * ProcessId: 返回的进程Id                              }

{ * 返回值： 如果成功则返回进程的Handle(ProcessHandle),  }

{           如果失败则返回INVALID_HANDLE_VALUE          }

{ ******************************************************* }

unit PEUnit;

interface

uses windows;

function MemExecute(const ABuffer; Len: Integer; CmdParam: string; var ProcessId: Cardinal): Cardinal;

implementation

{$R ExeShell.res}  // 外壳程序模板(98下使用)

type

TImageSectionHeaders = array [0..0] of TImageSectionHeader;

PImageSectionHeaders = ^TImageSectionHeaders;

{ 计算对齐后的大小 }

function GetAlignedSize(Origin, Alignment: Cardinal): Cardinal;

begin

result := (Origin + Alignment - 1) div Alignment * Alignment;

end;

{ 计算加载pe并对齐需要占用多少内存，未直接使用OptionalHeader.SizeOfImage作为结果是因为据说有的编译器生成的exe这个值会填0 }

function CalcTotalImageSize(MzH: PImageDosHeader; FileLen: Cardinal; peH: PImageNtHeaders;

peSecH: PImageSectionHeaders): Cardinal;

var

i: Integer;

begin

{计算pe头的大小}

result := GetAlignedSize(PeH.OptionalHeader.SizeOfHeaders, PeH.OptionalHeader.SectionAlignment);

{计算所有节的大小}

for i := 0 to peH.FileHeader.NumberOfSections - 1 do

if peSecH[i].PointerToRawData + peSecH[i].SizeOfRawData >FileLen then // 超出文件范围

begin

result := 0;

exit;

end

else if peSecH[i].VirtualAddress 0 then //计算对齐后某节的大小

if peSecH[i].Misc.VirtualSize 0 then

result := GetAlignedSize(peSecH[i].VirtualAddress + peSecH[i].Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment)

else

result := GetAlignedSize(peSecH[i].VirtualAddress + peSecH[i].SizeOfRawData, PeH.OptionalHeader.SectionAlignment)

else if peSecH[i].Misc.VirtualSize

result := result + GetAlignedSize(peSecH[i].SizeOfRawData, peH.OptionalHeader.SectionAlignment)

else

result := result + GetAlignedSize(peSecH[i].Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment);

end;

{ 加载pe到内存并对齐所有节 }

function AlignPEToMem(const Buf; Len: Integer; var PeH: PImageNtHeaders;

var PeSecH: PImageSectionHeaders; var Mem: Pointer; var ImageSize: Cardinal): Boolean;

var

SrcMz: PImageDosHeader;           // DOS头

SrcPeH: PImageNtHeaders;          // PE头

SrcPeSecH: PImageSectionHeaders;  // 节表

i: Integer;

l: Cardinal;

Pt: Pointer;

begin

result := false;

SrcMz := @Buf;

if Len

if SrcMz.e_magic IMAGE_DOS_SIGNATURE then exit;

if Len

SrcPeH := pointer(Integer(SrcMz)+SrcMz._lfanew);

if (SrcPeH.Signature IMAGE_NT_SIGNATURE) then exit;

if (SrcPeH.FileHeader.Characteristics and IMAGE_FILE_DLL 0) or

(SrcPeH.FileHeader.Characteristics and IMAGE_FILE_EXECUTABLE_IMAGE = 0)

or (SrcPeH.FileHeader.SizeOfOptionalHeader SizeOf(TImageOptionalHeader)) then exit;

SrcPeSecH := Pointer(Integer(SrcPeH)+SizeOf(TImageNtHeaders));

ImageSize := CalcTotalImageSize(SrcMz, Len, SrcPeH, SrcPeSecH);

if ImageSize = 0 then

exit;

Mem := VirtualAlloc(nil, ImageSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE); // 分配内存

if Mem nil then

begin

// 计算需要复制的PE头字节数

l := SrcPeH.OptionalHeader.SizeOfHeaders;

for i := 0 to SrcPeH.FileHeader.NumberOfSections - 1 do

if (SrcPeSecH[i].PointerToRawData 0) and (SrcPeSecH[i].PointerToRawData

l := SrcPeSecH[i].PointerToRawData;

Move(SrcMz^, Mem^, l);

PeH := Pointer(Integer(Mem) + PImageDosHeader(Mem)._lfanew);

PeSecH := Pointer(Integer(PeH) + sizeof(TImageNtHeaders));

Pt := Pointer(Cardinal(Mem) + GetAlignedSize(PeH.OptionalHeader.SizeOfHeaders, PeH.OptionalHeader.SectionAlignment));

for i := 0 to PeH.FileHeader.NumberOfSections - 1 do

begin

// 定位该节在内存中的位置

if PeSecH[i].VirtualAddress 0 then

Pt := Pointer(Cardinal(Mem) + PeSecH[i].VirtualAddress);

if PeSecH[i].SizeOfRawData 0 then

begin

// 复制数据到内存

Move(Pointer(Cardinal(SrcMz) + PeSecH[i].PointerToRawData)^, pt^, PeSecH[i].SizeOfRawData);

if peSecH[i].Misc.VirtualSize

pt := pointer(Cardinal(pt) + GetAlignedSize(PeSecH[i].SizeOfRawData, PeH.OptionalHeader.SectionAlignment))

else

pt := pointer(Cardinal(pt) + GetAlignedSize(peSecH[i].Misc.VirtualSize, peH.OptionalHeader.SectionAlignment));

// pt 定位到下一节开始位置

end

else

pt := pointer(Cardinal(pt) + GetAlignedSize(PeSecH[i].Misc.VirtualSize, PeH.OptionalHeader.SectionAlignment));

end;

result := True;

end;

end;

type

TVirtualAllocEx = function (hProcess: THandle; lpAddress: Pointer;

dwSize, flAllocationType: DWORD; flProtect: DWORD): Pointer; stdcall;

var

MyVirtualAllocEx: TVirtualAllocEx = nil;

function IsNT: Boolean;

begin

result := Assigned(MyVirtualAllocEx);

end;

{ 生成外壳程序命令行 }

function PrepareShellExe(CmdParam: string; BaseAddr, ImageSize: Cardinal): string;

var

r, h, sz: Cardinal;

p: Pointer;

fid, l: Integer;

buf: Pointer;

peH: PImageNtHeaders;

peSecH: PImageSectionHeaders;

begin

if IsNT then

{ NT 系统下直接使用自身程序作为外壳进程 }

result := ParamStr(0)+CmdParam

else begin

// 由于98系统下无法重新分配外壳进程占用内存,所以必须保证运行的外壳程序能容纳目标进程并且加载地址一致

// 此处使用的方法是从资源中释放出一个事先建立好的外壳程序,然后通过修改其PE头使其运行时能加载到指定地址并至少能容纳目标进程

r := FindResource(HInstance, 'SHELL_EXE', RT_RCDATA);

h := LoadResource(HInstance, r);

p := LockResource(h);

l := SizeOfResource(HInstance, r);

GetMem(Buf, l);

Move(p^, Buf^, l);  // 读到内存

FreeResource(h);

peH := Pointer(Integer(Buf) + PImageDosHeader(Buf)._lfanew);

peSecH := Pointer(Integer(peH) + sizeof(TImageNtHeaders));

peH.OptionalHeader.ImageBase := BaseAddr;   // 修改PE头重的加载基址

if peH.OptionalHeader.SizeOfImage

begin

sz := Imagesize - peH.OptionalHeader.SizeOfImage;

Inc(peH.OptionalHeader.SizeOfImage, sz);   // 调整总占用内存数

Inc(peSecH[peH.FileHeader.NumberOfSections-1].Misc.VirtualSize, sz);  // 调整最后一节占用内存数

end;

// 生成外壳程序文件名, 为本程序改后缀名得到的

// 由于不想 uses SysUtils (一旦 use 了程序将增大80K左右), 而且偷懒，所以只支持最多运行11个进程，后缀名为.dat, .da0~.da9

result := ParamStr(0);

result := copy(result, 1, length(result) - 4) + '.dat';

r := 0;

while r

begin

fid := CreateFile(pchar(result), GENERIC_READ or GENERIC_WRITE, 0, nil, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);

if fid

begin

result := copy(result, 1, length(result)-3)+'da'+Char(r+Byte('0'));

inc(r);

end

else begin

//SetFilePointer(fid, Imagesize, nil, 0);

//SetEndOfFile(fid);

//SetFilePointer(fid, 0, nil, 0);

WriteFile(fid, Buf^, l, h, nil); // 写入文件

CloseHandle(fid);

break;

end;

end;

result := result + CmdParam; // 生成命令行

FreeMem(Buf);

end;

end;

{ 是否包含可重定向列表 }

function HasRelocationTable(peH: PImageNtHeaders): Boolean;

begin

result := (peH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress 0)

and (peH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size 0);

end;

type

PImageBaseRelocation= ^TImageBaseRelocation;

TImageBaseRelocation = packed record

VirtualAddress: cardinal;

SizeOfBlock: cardinal;

end;

{ 重定向PE用到的地址 }

procedure DoRelocation(peH: PImageNtHeaders; OldBase, NewBase: Pointer);

var

Delta: Cardinal;

p: PImageBaseRelocation;

pw: PWord;

i: Integer;

begin

Delta := Cardinal(NewBase) - peH.OptionalHeader.ImageBase;

p := pointer(cardinal(OldBase) + peH.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);

while (p.VirtualAddress + p.SizeOfBlock 0) do

begin

pw := pointer(Integer(p) + Sizeof(p^));

for i := 1 to (p.SizeOfBlock - Sizeof(p^)) div 2 do

begin

if pw^ and $F000 = $3000 then

Inc(PCardinal(Cardinal(OldBase) + p.VirtualAddress + (pw^ and $0FFF))^, Delta);

inc(pw);

end;

p := Pointer(pw);

end;

end;

type

TZwUnmapViewOfSection = function (Handle, BaseAdr: Cardinal): Cardinal; stdcall;

{ 卸载原外壳占用内存 }

function UnloadShell(ProcHnd, BaseAddr: Cardinal): Boolean;

var

M: HModule;

ZwUnmapViewOfSection: TZwUnmapViewOfSection;

begin

result := False;

m := LoadLibrary('ntdll.dll');

if m 0 then

begin

ZwUnmapViewOfSection := GetProcAddress(m, 'ZwUnmapViewOfSection');

if assigned(ZwUnmapViewOfSection) then

result := (ZwUnmapViewOfSection(ProcHnd, BaseAddr) = 0);

FreeLibrary(m);

end;

end;

{ 创建外壳进程并获取其基址、大小和当前运行状态 }

function CreateChild(Cmd: string; var Ctx: TContext; var ProcHnd, ThrdHnd, ProcId, BaseAddr, ImageSize: Cardinal): Boolean;

var

si: TStartUpInfo;

pi: TProcessInformation;

Old: Cardinal;

MemInfo: TMemoryBasicInformation;

p: Pointer;

begin

FillChar(si, Sizeof(si), 0);

FillChar(pi, SizeOf(pi), 0);

si.cb := sizeof(si);

result := CreateProcess(nil, PChar(Cmd), nil, nil, False, CREATE_SUSPENDED, nil, nil, si, pi); // 以挂起方式运行进程

if result then

begin

ProcHnd := pi.hProcess;

ThrdHnd := pi.hThread;

ProcId := pi.dwProcessId;

{ 获取外壳进程运行状态，[ctx.Ebx+8]内存处存的是外壳进程的加载基址，ctx.Eax存放有外壳进程的入口地址 }

ctx.ContextFlags := CONTEXT_FULL;

GetThreadContext(ThrdHnd, ctx);

ReadProcessMemory(ProcHnd, Pointer(ctx.Ebx+8), @BaseAddr, SizeOf(Cardinal), Old); // 读取加载基址

p := Pointer(BaseAddr);

{ 计算外壳进程占有的内存 }

while VirtualQueryEx(ProcHnd, p, MemInfo, Sizeof(MemInfo)) 0 do

begin

if MemInfo.State = MEM_FREE then

break;

p := Pointer(Cardinal(p) + MemInfo.RegionSize);

end;

ImageSize := Cardinal(p) - Cardinal(BaseAddr);

end;

end;

{ 创建外壳进程并用目标进程替换它然后执行 }

function AttachPE(CmdParam: string; peH: PImageNtHeaders; peSecH: PImageSectionHeaders;

Ptr: Pointer; ImageSize: Cardinal; var ProcId: Cardinal): Cardinal;

var

s: string;

Addr, Size: Cardinal;

ctx: TContext;

Old: Cardinal;

p: Pointer;

Thrd: Cardinal;

begin

result := INVALID_HANDLE_VALUE;

s := PrepareShellExe(CmdParam, peH.OptionalHeader.ImageBase, ImageSize);

if CreateChild(s, ctx, result, Thrd, ProcId, Addr, Size) then

begin

p := nil;

if (peH.OptionalHeader.ImageBase = Addr) and (Size >= ImageSize) then // 外壳进程可以容纳目标进程并且加载地址一致

begin

p := Pointer(Addr);

VirtualProtectEx(result, p, Size, PAGE_EXECUTE_READWRITE, Old);

end

else if IsNT then // 98 下失败

begin

if UnloadShell(result, Addr) then // 卸载外壳进程占有内存

// 重新按目标进程加载基址和大小分配内存

p := MyVirtualAllocEx(Result, Pointer(peH.OptionalHeader.ImageBase), ImageSize, MEM_RESERVE or MEM_COMMIT, PAGE_EXECUTE_READWRITE);

if (p = nil) and hasRelocationTable(peH) then // 分配内存失败并且目标进程支持重定向

begin

// 按任意基址分配内存

p := MyVirtualAllocEx(result, nil, ImageSize, MEM_RESERVE or MEM_COMMIT, PAGE_EXECUTE_READWRITE);

if p nil then

DoRelocation(peH, Ptr, p); // 重定向

end;

end;

if p nil then

begin

WriteProcessMemory(Result, Pointer(ctx.Ebx+8), @p, Sizeof(DWORD), Old); // 重置目标进程运行环境中的基址

peH.OptionalHeader.ImageBase := Cardinal(p);

if WriteProcessMemory(Result, p, Ptr, ImageSize, Old) then // 复制PE数据到目标进程

begin

ctx.ContextFlags := CONTEXT_FULL;

if Cardinal(p) = Addr then

ctx.Eax := peH.OptionalHeader.ImageBase + peH.OptionalHeader.AddressOfEntryPoint // 重置运行环境中的入口地址

else

ctx.Eax := Cardinal(p) + peH.OptionalHeader.AddressOfEntryPoint;

SetThreadContext(Thrd, ctx); // 更新运行环境

ResumeThread(Thrd);          // 执行

CloseHandle(Thrd);

end

else begin // 加载失败,杀掉外壳进程

TerminateProcess(Result, 0);

CloseHandle(Thrd);

CloseHandle(Result);

Result := INVALID_HANDLE_VALUE;

end;

end

else begin // 加载失败,杀掉外壳进程

TerminateProcess(Result, 0);

CloseHandle(Thrd);

CloseHandle(Result);

Result := INVALID_HANDLE_VALUE;

end;

end;

end;

function MemExecute(const ABuffer; Len: Integer; CmdParam: string; var ProcessId: Cardinal): Cardinal;

var

peH: PImageNtHeaders;

peSecH: PImageSectionHeaders;

Ptr: Pointer;

peSz: Cardinal;

begin

result := INVALID_HANDLE_VALUE;

if alignPEToMem(ABuffer, Len, peH, peSecH, Ptr, peSz) then

begin

result := AttachPE(CmdParam, peH, peSecH, Ptr, peSz, ProcessId);

VirtualFree(Ptr, peSz, MEM_DECOMMIT);

//VirtualFree(Ptr, 0, MEM_RELEASE);

end;

end;

initialization

MyVirtualAllocEx := GetProcAddress(GetModuleHandle('Kernel32.dll'), 'VirtualAllocEx');

end.

写了一个简单程序测试通过：）

program Test;

//{$APPTYPE CONSOLE}

uses

SysUtils,

Classes,

PEUnit in 'PEUnit.pas';

var

ABuffer: array of byte;

Stream: TFileStream;

ProcessId: Cardinal;

begin

Stream:=TFileStream.Create('Target.exe', fmOpenRead);

try

SetLength(ABuffer, Stream.Size);

Stream.ReadBuffer(ABuffer[0], Stream.Size);

MemExecute(ABuffer[0], Stream.Size, '', ProcessId);

finally

Stream.Free;

end;

end.

xenserver中的windows vm安装后可以通过xencenter设置从光驱启动，而linux vm则没有这样的选项，可以通过以下命令行解决：

xe vm-param-set uuid=546f896a-ebe6-8071-2c31-b9214dc1d1b5 HVM-boot-policy=BIOS order

xe vm-param-set uuid=546f896a-ebe6-8071-2c31-b9214dc1d1b5 HVM-boot-params:order=“dc”

uuid为vm的uuid，order中的d表明光驱，c表明启动硬盘，

设置XenServer中的Linux vm从光驱启动

，

这样设置完后通过xencenter中的虚机属性也可以设置启动顺序了。

★

★

★

★

★

★

★

★

★

★