dxnntpservercore.pas

Well known and usefull component for delphi 7

unit DXNNTPServerCore;

interface

///////////////////////////////////////////////////////////////////////////////
//    Component: TDXNNTPServerCore
//       Author: G.E. Ozz Nixon Jr. ([e-mail])
// ========================================================================
// Source Owner: DX, Inc. 1995-2003
//    Copyright: All code is the property of DX, Inc. Licensed for
//               resell by Brain Patchwork DX (tm) and part of the
//               DX (r) product lines, which are (c) 1999-2003
//               DX, Inc. Source may not be distributed without
//               written permission from both Brain Patchwork DX,
//               and DX, Inc.
//      License: (Reminder), None of this code can be added to other
//               developer products without permission. This includes
//               but not limited to DCU's, DCP's, DLL's, OCX's, or
//               any other form of merging our technologies. All of
//               your products released to a public consumer be it
//               shareware, freeware, commercial, etc. must contain a
//               license notification somewhere visible in the
//               application.
//               Example is Internet Explorer - Help->About screen
//               shows the licensed code contained in the application.
// Code Version: (4th Generation Code)
// ========================================================================
//  Description: implements NNTP (network news transport protocol)
// ========================================================================
// Rev 3 - RFC2980 extensions incorporated
///////////////////////////////////////////////////////////////////////////////

uses
  Classes,
  DXServerCore;

{$I DXSock.def}

type
  NNTPTSimpleEvent = procedure(ClientThread: TDXClientThread) of object;
  NNTPTOtherEvent = procedure(ClientThread: TDXClientThread; Command: string; Parm: string; var Handled: Boolean) of object;
  NNTPTDoByIDEvent = procedure(ClientThread: TDXClientThread; ActualID: string) of object;
  NNTPTDoByNoEvent = procedure(ClientThread: TDXClientThread; ActualNumber: integer) of object;
  NNTPTBasicEvent = procedure(ClientThread: TDXClientThread; Parm: string) of object;
  NNTPTComplexEvent = procedure(ClientThread:TDXClientThread;Parm1,Parm2:string) of object;

  TDXNNTPServerCore = class(TDXServerCore)
  private
    fOnCommandAuthInfo: NNTPTComplexEvent; {authinfo user [data]}
                                           {authinfo pass [data]}
                                           {authinfo simple [user] [pass]}
                                           {authinfo generic authenticator arguements}
    fOnCommandArticleID: NNTPTDoByIDEvent; {article <message-id>}
    fOnCommandArticleNO: NNTPTDoByNoEvent; {article 7872}
    fOnCommandBodyID: NNTPTDoByIDEvent; {body <message-id>}
    fOnCommandBodyNO: NNTPTDoByNoEvent; {body 7872}
    fOnCommandHeadID: NNTPTDoByIDEvent; {head <message-id>}
    fOnCommandHeadNO: NNTPTDoByNoEvent; {head 7872}
    fOnCommandStatID: NNTPTDoByIDEvent; {stat <message-id>} {useless!}
    fOnCommandStatNO: NNTPTDoByNoEvent; {stat 7872}
    fOnCommandGroup: NNTPTBasicEvent; {group net.news}
    fOnCommandList: NNTPTBasicEvent; {list [optional parm]}
                                     {list active (RFC2980)}
                                     {list active.times (RFC2980)}
                                     {list distributions (RFC2980)}
                                     {list distrib.pats (RFC2980)}
                                     {list newsgroups (RFC2980)}
                                     {list overview.fmt (RFC2980)}
                                     {list subscriptions (RFC2980)}
    fOnCommandHelp: NNTPTSimpleEvent; {help}
    fOnCommandIHave: NNTPTDoByIDEvent; {ihave <message-id>}
    fOnCommandLast: NNTPTSimpleEvent; {last}
    fOnCommandMode: NNTPTBasicEvent; {mode reader}
                                     {mode stream (RFC2980)}
    fOnCommandNewGroups: NNTPTBasicEvent; {newsgroups yymmdd hhmmss [GMT] <distributions>}
    fOnCommandNewNews: NNTPTBasicEvent; {newnews newsgroups yymmdd hhmmss [GMT] <distributions>}
    fOnCommandNext: NNTPTSimpleEvent; {next}
    fOnCommandPost: NNTPTSimpleEvent; {post}
    fOnCommandQuit: NNTPTSimpleEvent; {quit}
    fOnCommandSlave: NNTPTSimpleEvent; {slave}
{not in RFC977}
    fOnCommandXOver: NNTPTBasicEvent; {xover start#-stop#}
    fOnCommandXHDR: NNTPTBasicEvent; {xhdr header start#-stop#}
    fOnCommandDate: NNTPTSimpleEvent; {date}
{in RFC2980}
    fOnCommandCheck:NNTPTDoByIDEvent; {check <message-id>}
    fOnCommandTakethis:NNTPTDoByIDEvent; {takethis <message-id>}
    fOnCommandXReplic:NNTPTBasicEvent; {xreplic ggg:nnn[,ggg:nnn...]}
    fOnCommandListgroup:NNTPTBasicEvent; {listgroup [ggg]}
    fOnCommandXGTitle:NNTPTBasicEvent; {xgtitle [ggg]}
    fOnCommandXIndex:NNTPTBasicEvent; {xindex ggg}
    fOnCommandXPAT:NNTPTComplexEvent; {xpat header range|<message-id> pattern}
    fOnCommandXPath:NNTPTDoByIDEvent; {xpath <message-id>}
    fOnCommandXThread:NNTPTBasicEvent; {xthread [dbinit|thread]}
    fOnCommandCancel:NNTPTDoByIDEvent; {cancel <message-id>}
    fOnCommandSendMe:NNTPTDoByIDEvent; {sendme <message-id>}
    fOnCommandRMGroup:NNTPTBasicEvent; {rmgroup ggg}
    fOnCommandSendSys:NNTPTSimpleEvent; {sendsys}
    fOnCommandVersion:NNTPTSimpleEvent; {version}
{other support}
    fOnCommandOther: NNTPTOtherEvent;
  protected
    Procedure SetOnCommandAuthInfo(value:NNTPTComplexEvent);
    Procedure SetOnCommandArticleID(value:NNTPTDoByIDEvent);
    Procedure SetOnCommandArticleNO(value:NNTPTDoByNOEvent);
    Procedure SetOnCommandBodyID(value:NNTPTDoByIDEvent);
    Procedure SetOnCommandBodyNO(value:NNTPTDoByNOEvent);
    Procedure SetOnCommandHeadID(value:NNTPTDoByIDEvent);
    Procedure SetOnCommandHeadNO(value:NNTPTDoByNOEvent);
    Procedure SetOnCommandStatID(value:NNTPTDoByIDEvent);
    Procedure SetOnCommandStatNO(value:NNTPTDoByNOEvent);
    Procedure SetOnCommandGroup(value:NNTPTBasicEvent);
    Procedure SetOnCommandList(value:NNTPTBasicEvent);
    Procedure SetOnCommandHelp(value:NNTPTSimpleEvent);
    Procedure SetOnCommandIHave(value:NNTPTDoByIDEvent);
    Procedure SetOnCommandLast(value:NNTPTSimpleEvent);
    Procedure SetOnCommandMode(value:NNTPTBasicEvent);
    Procedure SetOnCommandNewGroups(value:NNTPTBasicEvent);
    Procedure SetOnCommandNewNews(value:NNTPTBasicEvent);
    Procedure SetOnCommandNext(value:NNTPTSimpleEvent);
    Procedure SetOnCommandPost(value:NNTPTSimpleEvent);
    Procedure SetOnCommandQuit(value:NNTPTSimpleEvent);
    Procedure SetOnCommandSlave(value:NNTPTSimpleEvent);
    Procedure SetOnCommandXOver(value:NNTPTBasicEvent);
    Procedure SetOnCommandXHDR(value:NNTPTBasicEvent);
    Procedure SetOnCommandDate(value:NNTPTSimpleEvent);
    Procedure SetOnCommandListGroup(value:NNTPTBasicEvent);
{new as of v2 rev 3}
    Procedure SetOnCommandCheck(value:NNTPTDoByIDEvent);
    Procedure SetOnCommandTakeThis(value:NNTPTDoByIDEvent);
    Procedure SetOnCommandXReplic(value:NNTPTBasicEvent);
    Procedure SetOnCommandXGTitle(value:NNTPTBasicEvent);
    Procedure SetOnCommandXIndex(value:NNTPTBasicEvent);
    Procedure SetOnCommandXPAT(value:NNTPTComplexEvent);
    Procedure SetOnCommandXPATH(value:NNTPTDoByIDEvent);
    Procedure SetOnCommandXThread(value:NNTPTBasicEvent);
    Procedure SetOnCommandCancel(value:NNTPTDoByIDEvent);
    Procedure SetOnCommandSendMe(value:NNTPTDoByIDEvent);
    Procedure SetOnCommandRMGroup(value:NNTPTBasicEvent);
    Procedure SetOnCommandSendSys(value:NNTPTSimpleEvent);
    Procedure SetOnCommandVersion(value:NNTPTSimpleEvent);
  public
    constructor Create(AOwner:TComponent); {$IFNDEF OBJECTS_ONLY} override; {$ENDIF}
    destructor Destroy; override;
    procedure SayHello(ClientThread:TDXClientThread;Header:String);
    procedure SayGoodbye(ClientThread:TDXClientThread;Footer:String);
    procedure ProcessSession(ClientThread:TDXClientThread);
    Procedure AddBasicEvent(Command:String;EventProc:NNTPTBasicEvent);
    Procedure AddSimpleEvent(Command:String;EventProc:NNTPTSimpleEvent);
    Procedure AddComplexEvent(Command:String;EventProc:NNTPTComplexEvent);
    Procedure AddDoByIDEvent(Command:String;EventProc:NNTPTDoByIDEvent);
    Procedure AddDoByNOEvent(Command:String;EventProc:NNTPTDoByNOEvent);
  published
    property OnCommandAuthInfo: NNTPTComplexEvent read fOnCommandAuthInfo
                                            write SetOnCommandAuthInfo;
    property OnCommandArticleID: NNTPTDoByIDEvent read fOnCommandArticleID
                                              write SetOnCommandArticleID;
    property OnCommandArticleNo: NNTPTDoByNoEvent read fOnCommandArticleNo
                                              write SetOnCommandArticleNo;
    property OnCommandBodyID: NNTPTDoByIDEvent read fOnCommandBodyID
                                           write SetOnCommandBodyID;
    property OnCommandBodyNo: NNTPTDoByNoEvent read fOnCommandBodyNo
                                           write SetOnCommandBodyNo;
    property OnCommandHeadID: NNTPTDoByIDEvent read fOnCommandHeadID
                                           write SetOnCommandHeadID;
    property OnCommandHeadNo: NNTPTDoByNoEvent read fOnCommandHeadNo
                                           write SetOnCommandHeadNo;
    property OnCommandStatID: NNTPTDoByIDEvent read fOnCommandStatID
                                           write SetOnCommandStatID;
    property OnCommandStatNo: NNTPTDoByNoEvent read fOnCommandStatNo
                                           write SetOnCommandStatNo;
    property OnCommandGroup: NNTPTBasicEvent read fOnCommandGroup
                                         write SetOnCommandGroup;
    property OnCommandList: NNTPTBasicEvent read fOnCommandList
                                       write SetOnCommandList;
    property OnCommandHelp: NNTPTSimpleEvent read fOnCommandHelp
                                      write SetOnCommandHelp;
    property OnCommandIHave: NNTPTDoByIDEvent read fOnCommandIHave
                                          write SetOnCommandIHave;
    property OnCommandLast: NNTPTSimpleEvent read fOnCommandLast
                                      write SetOnCommandLast;
    property OnCommandMode: NNTPTBasicEvent read fOnCommandMode
                                       write SetOnCommandMode;
    property OnCommandNewGroups: NNTPTBasicEvent read fOnCommandNewGroups
                                            write SetOnCommandNewGroups;
    property OnCommandNewNews: NNTPTBasicEvent read fOnCommandNewNews
                                          write SetOnCommandNewNews;
    property OnCommandNext: NNTPTSimpleEvent read fOnCommandNext
                                      write SetOnCommandNext;
    property OnCommandPost: NNTPTSimpleEvent read fOnCommandPost
                                      write SetOnCommandPost;
    property OnCommandQuit: NNTPTSimpleEvent read fOnCommandQuit
                                      write SetOnCommandQuit;
    property OnCommandSlave: NNTPTSimpleEvent read fOnCommandSlave
                                       write SetOnCommandSlave;
    property OnCommandXOver: NNTPTBasicEvent read fOnCommandXOver
                                        write SetOnCommandXOver;
    property OnCommandXHDR: NNTPTBasicEvent read fOnCommandXHDR
                                       write SetOnCommandXHDR;
    property OnCommandDate: NNTPTSimpleEvent read fOnCommandDate
                                      write SetOnCommandDate;
    property OnCommandListgroup: NNTPTBasicEvent read fOnCommandListGroup
                                                 write SetOnCommandListGroup;
// 2.3
    property OnCommandCheck:NNTPTDoByIDEvent read fOnCommandCheck
                                             write SetOnCommandCheck;
    property OnCommandTakethis:NNTPTDoByIDEvent read fOnCommandTakethis
                                                 write SetOnCommandTakethis;
    property OnCommandXReplic:NNTPTBasicEvent read fOnCommandXReplic
                                               write SetOnCommandXReplic;
    property OnCommandXGTitle:NNTPTBasicEvent read fOnCommandXGTitle
                                               write SetOnCommandXGTitle;
    property OnCommandXIndex:NNTPTBasicEvent read fOnCommandXIndex
                                              write SetOnCommandXIndex;
    property OnCommandXPAT:NNTPTComplexEvent read fOnCommandXPAT
                                              write SetOnCommandXPAT;
    property OnCommandXPath:NNTPTDoByIDEvent read fOnCommandXPath
                                              write SetOnCommandXPath;
    property OnCommandXThread:NNTPTBasicEvent read fOnCommandXThread
                                               write SetOnCommandXThread;
    property OnCommandCancel:NNTPTDoByIDEvent read fOnCommandCancel
                                               write SetOnCommandCancel;
    property OnCommandSendMe:NNTPTDoByIDEvent read fOnCommandSendMe
                                               write SetOnCommandSendMe;
    property OnCommandRMGroup:NNTPTBasicEvent read fOnCommandRMGroup
                                               write SetOnCommandRMGroup;
    property OnCommandSendSys:NNTPTSimpleEvent read fOnCommandSendSys
                                                write SetOnCommandSendSys;
    property OnCommandVersion:NNTPTSimpleEvent read fOnCommandVersion
                                                write SetOnCommandVersion;
    property OnCommandOther: NNTPTOtherEvent read fOnCommandOther
                                             write fOnCommandOther;
  end;

implementation

uses
   DXSock,
   DXString;

Type
  PNNTPBasicEvent=^TNNTPBasicEvent;
  TNNTPBasicEvent=record
     Tag:Integer;
     Command:String;
     EventProcedure:NNTPTBasicEvent;
  End;
  PNNTPSimpleEvent=^TNNTPSimpleEvent;
  TNNTPSimpleEvent=record
     Tag:Integer;
     Command:String;
     EventProcedure:NNTPTSimpleEvent;
  End;
  PNNTPComplexEvent=^TNNTPComplexEvent;
  TNNTPComplexEvent=record
     Tag:Integer;
     Command:String;
     EventProcedure:NNTPTComplexEvent;
  End;
  PNNTPDoByIDEvent=^TNNTPDoByIDEvent;
  TNNTPDoByIDEvent=record
     Tag:Integer;
     Command:String;
     EventProcedure:NNTPTDoByIDEvent;
  End;
  PNNTPDoByNOEvent=^TNNTPDoByNOEvent;
  TNNTPDoByNOEvent=record
     Tag:Integer;
     Command:String;
     EventProcedure:NNTPTDoByNOEvent;
  End;

constructor TDXNNTPServerCore.Create(AOwner:TComponent);
begin
   inherited Create(AOwner);
   ServerPort:=119;
end;

destructor TDXNNTPServerCore.Destroy;
Var
   PBasicEvent:PNNTPBasicEvent;
   PSimpleEvent:PNNTPSimpleEvent;
   PComplexEvent:PNNTPComplexEvent;
   PDoByIDEvent:PNNTPDoByIDEvent;
   PDoByNOEvent:PNNTPDoByNoEvent;

begin
   If Assigned(fEventArray) then Begin
      While fEventArray.Count>0 do Begin
         Case PNNTPBasicEvent(fEventArray[0]).Tag of
            1:Begin
              PBasicEvent:=fEventArray[0];
              Dispose(PBasicEvent);
            End;
            2:Begin
              PSimpleEvent:=fEventArray[0];
              Dispose(PSimpleEvent);
            End;
            3:Begin
              PComplexEvent:=fEventArray[0];
              Dispose(PComplexEvent);
            End;
            4:Begin
              PDoByIDEvent:=fEventArray[0];
              Dispose(PDoByIDEvent);
            End;
            5:Begin
              PDoByNoEvent:=fEventArray[0];
              Dispose(PDoByNOEvent);
            End;
         End;
         fEventArray.Delete(0);
      End;
   End;
   inherited Destroy;
end;

Procedure TDXNNTPServerCore.AddBasicEvent(Command:String;EventProc:NNTPTBasicEvent);
Var
   PBasicEvent:PNNTPBasicEvent;
   Loop:Integer;

Begin
   Command:=Uppercase(Command);
   Loop:=0;
   While Loop<fEventArray.Count do Begin
      If PNNTPBasicEvent(fEventArray[Loop]).Command=Command then Begin
         PNNTPBasicEvent(fEventArray[Loop]).EventProcedure:=EventProc;
         Exit;
      End
      Else Inc(Loop);
   End;
   New(PBasicEvent);
   PBasicEvent.Tag:=1;      // Denotes Event in fEventArray is a TBasicEvent!
   PBasicEvent.Command:=Command;
   PBasicEvent.EventProcedure:=EventProc;
   fEventArray.Add(PBasicEvent);
End;

Procedure TDXNNTPServerCore.AddSimpleEvent(Command:String;EventProc:NNTPTSimpleEvent);
Var
   PSimpleEvent:PNNTPSimpleEvent;
   Loop:Integer;

Begin
   Command:=Uppercase(Command);
   Loop:=0;
   While Loop<fEventArray.Count do Begin
      If PNNTPSimpleEvent(fEventArray[Loop]).Command=Command then Begin
         PNNTPSimpleEvent(fEventArray[Loop]).EventProcedure:=EventProc;
         Exit;
      End
      Else Inc(Loop);
   End;
   New(PSimpleEvent);
   PSimpleEvent.Tag:=2;      // Denotes Event in fEventArray is a TSimpleEvent!
   PSimpleEvent.Command:=Command;
   PSimpleEvent.EventProcedure:=EventProc;
   fEventArray.Add(PSimpleEvent);
End;

Procedure TDXNNTPServerCore.AddComplexEvent(Command:String;EventProc:NNTPTComplexEvent);
Var
   PComplexEvent:PNNTPComplexEvent;
   Loop:Integer;

Begin