/[RomCheater]/trunk/Win32/Sojaner.MemoryScanner/MemoryProviers/BaseMemoryProvider.cs
ViewVC logotype

Diff of /trunk/Win32/Sojaner.MemoryScanner/MemoryProviers/BaseMemoryProvider.cs

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 250 by william, Sun Jun 3 16:09:05 2012 UTC revision 251 by william, Sun Jun 3 16:32:58 2012 UTC
# Line 9  using System.IO; Line 9  using System.IO;
9    
10  namespace Sojaner.MemoryScanner.MemoryProviers  namespace Sojaner.MemoryScanner.MemoryProviers
11  {  {
12        #region public abstract class BaseMemoryProvider
13      public abstract class BaseMemoryProvider :      public abstract class BaseMemoryProvider :
14          IPatchMemory,          IPatchMemory,
15          IReadMemory,          IReadMemory,
# Line 459  namespace Sojaner.MemoryScanner.MemoryPr Line 460  namespace Sojaner.MemoryScanner.MemoryPr
460          #endregion          #endregion
461          #endregion          #endregion
462      }      }
463        #endregion
464    
465        #region MemoryScanner-r204
466        namespace r204
467        {
468            #region public abstract class BaseMemoryProvider
469            public abstract class BaseMemoryProvider :
470                IPatchMemory,
471                IReadMemory,
472                IAcceptsProcess<Process>,
473                IAcceptsPlugin<IConfigPlugin>,
474                IMemoryReader,
475                IMemoryWriter,
476                IFileWriter
477            {
478                private Sojaner.MemoryScanner.r204.ProcessMemoryReader provider;
479                public BaseMemoryProvider() { this.AcceptedPlugin = null; this.AcceptedProcess = null; isClosed = true; isOpen = false; }
480                public BaseMemoryProvider(IConfigPlugin config) : this() { this.AcceptedPlugin = config; }
481                public BaseMemoryProvider(IConfigPlugin config, Process process) : this() { this.AcceptedPlugin = config; this.AcceptedProcess = process; }
482                public BaseMemoryProvider(IAcceptsProcessAndConfig config) : this() { this.AcceptedPlugin = config.AcceptedPlugin; this.AcceptedProcess = config.AcceptedProcess; }
483    
484    
485                private bool isOpen { get; set; }
486                private bool isClosed { get; set; }
487    
488                #region Open/Close Provider
489                #region public virtual void OpenProvider()
490                public virtual void OpenProvider()
491                {
492                    if (isOpen)
493                    {
494                        logger.Warn.WriteLine("Provider has already been opened.");
495                        return;
496                    }
497                    try
498                    {
499                        provider = new Sojaner.MemoryScanner.r204.ProcessMemoryReader();
500                        provider.ReadProcess = this.AcceptedProcess;
501                        if (provider.ReadProcess == null) { logger.Error.WriteLine("{0}.OpenProvider() Could not attach to process: {1}", "", this.GetType().Name, this.AcceptedProcess.ToString()); return; }
502                        provider.OpenProcess();
503                        isOpen = true;
504                        isClosed = false;
505                    }
506                    catch (Exception ex)
507                    {
508                        logger.Error.WriteLine("Failed to open provider: {0}{1}", System.Environment.NewLine, ex.ToString());
509                        isOpen = false;
510                        isClosed = true;
511                    }
512                }
513                #endregion
514                #region public virtual void CloseProvider()
515                public virtual void CloseProvider()
516                {
517                    if (isClosed)
518                    {
519                        logger.Warn.WriteLine("Provider has already been closed.");
520                        return;
521                    }
522                    if (!isOpen)
523                    {
524                        logger.Warn.WriteLine("Provider cannot be closed, it was never opened...attempting to open provider.");
525                        OpenProvider();
526                        if (!isOpen)
527                        {
528                            logger.Warn.WriteLine("Could not open provider");
529                            return;
530                        }
531                    }
532                    try
533                    {
534                        //logger.VerboseDebug.WriteLine("CloseProvider(): System.Environment.StackTrace: {0}{1}", System.Environment.NewLine, System.Environment.StackTrace);
535                        if (provider == null) return;
536                        provider.CloseHandle();
537                        //provider = null; // free any memory associated with the provider
538                        isClosed = true;
539                        isOpen = false;
540                    }
541                    catch (Exception ex)
542                    {
543                        logger.Error.WriteLine("Failed to close provider: {0}{1}", System.Environment.NewLine, ex.ToString());
544                        isClosed = false;
545                        if (isOpen)
546                        {
547                            throw new Exception("Provider is failed to close and still open.");
548                        }
549                    }
550                }
551                #endregion
552                #endregion
553    
554                #region  IAcceptsProcess<Process> Members
555                public Process AcceptedProcess { get; set; }
556                #endregion
557                #region IAcceptsPlugin<IConfigPlugin> Members
558                public IConfigPlugin AcceptedPlugin { get; set; }
559                #endregion
560                #region EnsureProviderIsOpen methods : log and/or throw errors
561                private bool EnsureProviderIsOpen() { return EnsureProviderIsOpenOrThrowError(); }
562                private bool EnsureProviderIsOpenOrLogError() { return EnsureProviderIsOpenOrThrowOrLogError(false, true); }
563                private bool EnsureProviderIsOpenOrThrowError() { return EnsureProviderIsOpenOrThrowOrLogError(true, true); }
564                private bool EnsureProviderIsOpenOrThrowOrLogError(bool ThrowError, bool LogError)
565                {
566                    if (!isOpen)
567                    {
568                        try { throw new Exception("Memory operation could not be completed because the provider is not open"); }
569                        catch (Exception ex)
570                        {
571                            if (LogError)
572                                logger.Error.WriteLine(ex.ToString());
573                            if (ThrowError)
574                                throw ex;
575                            return false;
576                        }
577                    }
578                    return true;
579                }
580                #endregion
581    
582                #region IPatchMemory members
583                #region public virtual bool PatchMemory(int address, byte value)
584                public virtual bool PatchMemory(int address, byte value)
585                {
586                    if (!EnsureProviderIsOpen()) { return false; }
587                    int bytesWritten;
588                    byte[] bitData = BitConverter.GetBytes(value);
589                    provider.WriteProcessMemory(address, bitData, out bytesWritten);
590                    byte check = 0;
591                    ReadMemory(address, out check);
592                    if (check == value) return true;
593                    return false;
594                }
595                #endregion
596                #region public virtual bool PatchMemory(int address, sbyte value)
597                public virtual bool PatchMemory(int address, sbyte value)
598                {
599                    if (!EnsureProviderIsOpen()) { return false; }
600                    int bytesWritten;
601                    byte[] bitData = BitConverter.GetBytes(value);
602                    provider.WriteProcessMemory(address, bitData, out bytesWritten);
603                    sbyte check = 0;
604                    ReadMemory(address, out check);
605                    if (check == value) return true;
606                    return false;
607                }
608                #endregion
609                #region public virtual bool PatchMemory(int address, ushort value)
610                public virtual bool PatchMemory(int address, ushort value)
611                {
612                    if (!EnsureProviderIsOpen()) { return false; }
613                    int bytesWritten;
614                    byte[] bitData = BitConverter.GetBytes(value);
615                    provider.WriteProcessMemory(address, bitData, out bytesWritten);
616    
617                    ushort check = 0;
618                    ReadMemory(address, out check);
619                    if (check == value) return true;
620                    return false;
621                }
622                #endregion
623                #region public virtual bool PatchMemory(int address, short value)
624                public virtual bool PatchMemory(int address, short value)
625                {
626                    if (!EnsureProviderIsOpen()) { return false; }
627                    int bytesWritten;
628                    byte[] bitData = BitConverter.GetBytes(value);
629                    provider.WriteProcessMemory(address, bitData, out bytesWritten);
630    
631                    short check = 0;
632                    ReadMemory(address, out check);
633                    if (check == value) return true;
634                    return false;
635                }
636                #endregion
637                #region public virtual bool PatchMemory(int address, uint value)
638                public virtual bool PatchMemory(int address, uint value)
639                {
640                    if (!EnsureProviderIsOpen()) { return false; }
641                    int bytesWritten;
642                    byte[] bitData = BitConverter.GetBytes(value);
643                    provider.WriteProcessMemory(address, bitData, out bytesWritten);
644    
645                    uint check = 0;
646                    ReadMemory(address, out check);
647                    if (check == value) return true;
648                    return false;
649                }
650                #endregion
651                #region public virtual bool PatchMemory(int address, int value)
652                public virtual bool PatchMemory(int address, int value)
653                {
654                    if (!EnsureProviderIsOpen()) { return false; }
655                    int bytesWritten;
656                    byte[] bitData = BitConverter.GetBytes(value);
657                    provider.WriteProcessMemory(address, bitData, out bytesWritten);
658    
659                    int check = 0;
660                    ReadMemory(address, out check);
661                    if (check == value) return true;
662                    return false;
663                }
664                #endregion
665                #region public virtual bool PatchMemory(int address, ulong value)
666                public virtual bool PatchMemory(int address, ulong value)
667                {
668                    if (!EnsureProviderIsOpen()) { return false; }
669                    int bytesWritten;
670                    byte[] bitData = BitConverter.GetBytes(value);
671                    provider.WriteProcessMemory(address, bitData, out bytesWritten);
672    
673                    ulong check = 0;
674                    ReadMemory(address, out check);
675                    if (check == value) return true;
676                    return false;
677                }
678                #endregion
679                #region public virtual bool PatchMemory(int address, long value)
680                public virtual bool PatchMemory(int address, long value)
681                {
682                    if (!EnsureProviderIsOpen()) { return false; }
683                    int bytesWritten;
684                    byte[] bitData = BitConverter.GetBytes(value);
685                    provider.WriteProcessMemory(address, bitData, out bytesWritten);
686    
687                    long check = 0;
688                    ReadMemory(address, out check);
689                    if (check == value) return true;
690                    return false;
691                }
692                #endregion
693                #endregion
694    
695                #region IReadMemory members
696                #region public virtual bool ReadMemory(int address, out byte value)
697                public virtual bool ReadMemory(int address, out byte value)
698                {
699                    value = 0;
700                    if (!EnsureProviderIsOpen()) { return false; }
701                    try
702                    {
703                        int bytesReadSize;
704                        byte[] bitData;
705                        provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
706                        value = bitData[0];
707    
708                        return true;
709                    }
710                    catch
711                    {
712                        value = 0x00;
713                        return false;
714                    }
715                }
716                #endregion
717                #region public virtual bool ReadMemory(int address, out sbyte value)
718                public virtual bool ReadMemory(int address, out sbyte value)
719                {
720                    value = 0;
721                    if (!EnsureProviderIsOpen()) { return false; }
722                    try
723                    {
724                        int bytesReadSize;
725                        byte[] bitData;
726                        provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
727                        value = Convert.ToSByte(bitData[0]);
728    
729                        return true;
730                    }
731                    catch
732                    {
733                        value = 0x00;
734                        return false;
735                    }
736                }
737                #endregion
738                #region public virtual bool ReadMemory(int address, out ushort value)
739                public virtual bool ReadMemory(int address, out ushort value)
740                {
741                    value = 0;
742                    if (!EnsureProviderIsOpen()) { return false; }
743                    try
744                    {
745                        int bytesReadSize;
746                        byte[] bitData;
747                        provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
748                        value = BitConverter.ToUInt16(bitData, 0);
749    
750                        return true;
751                    }
752                    catch
753                    {
754                        value = 0x00;
755                        return false;
756                    }
757                }
758                #endregion
759                #region public virtual bool ReadMemory(int address, out short value)
760                public virtual bool ReadMemory(int address, out short value)
761                {
762                    value = 0;
763                    if (!EnsureProviderIsOpen()) { return false; }
764                    try
765                    {
766                        int bytesReadSize;
767                        byte[] bitData;
768                        provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
769                        value = BitConverter.ToInt16(bitData, 0);
770    
771                        return true;
772                    }
773                    catch
774                    {
775                        value = 0x00;
776                        return false;
777                    }
778                }
779                #endregion
780                #region public virtual bool ReadMemory(int address, out uint value)
781                public virtual bool ReadMemory(int address, out uint value)
782                {
783                    value = 0;
784                    if (!EnsureProviderIsOpen()) { return false; }
785                    try
786                    {
787                        int bytesReadSize;
788                        byte[] bitData;
789                        provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
790                        value = BitConverter.ToUInt32(bitData, 0);
791    
792                        return true;
793                    }
794                    catch
795                    {
796                        value = 0x00;
797                        return false;
798                    }
799                }
800                #endregion
801                #region public virtual bool ReadMemory(int address, out int value)
802                public virtual bool ReadMemory(int address, out int value)
803                {
804                    value = 0;
805                    if (!EnsureProviderIsOpen()) { return false; }
806                    try
807                    {
808                        int bytesReadSize;
809                        byte[] bitData;
810                        provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
811                        value = BitConverter.ToInt32(bitData, 0);
812    
813                        return true;
814                    }
815                    catch
816                    {
817                        value = 0x00;
818                        return false;
819                    }
820                }
821                #endregion
822                #region public virtual bool ReadMemory(int address, out ulong value)
823                public virtual bool ReadMemory(int address, out ulong value)
824                {
825                    value = 0;
826                    if (!EnsureProviderIsOpen()) { return false; }
827                    try
828                    {
829                        int bytesReadSize;
830                        byte[] bitData;
831                        provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
832                        value = BitConverter.ToUInt64(bitData, 0);
833    
834                        return true;
835                    }
836                    catch
837                    {
838                        value = 0x00;
839                        return false;
840                    }
841                }
842                #endregion
843                #region public virtual bool ReadMemory(int address, out long value)
844                public virtual bool ReadMemory(int address, out long value)
845                {
846                    value = 0;
847                    if (!EnsureProviderIsOpen()) { return false; }
848                    try
849                    {
850                        int bytesReadSize;
851                        byte[] bitData;
852                        provider.ReadProcessMemory(address, sizeof(byte), out bytesReadSize, out bitData);
853                        value = BitConverter.ToInt64(bitData, 0);
854    
855                        return true;
856                    }
857                    catch
858                    {
859                        value = 0x00;
860                        return false;
861                    }
862                }
863                #endregion
864                #endregion
865    
866                #region IMemoryReader members
867                #region public virtual bool ReadFirstNonZeroByte(int MemoryAddress, uint bytesToRead, out int address)
868                public virtual bool ReadFirstNonZeroByte(int MemoryAddress, uint bytesToRead, out int address)
869                {
870                    address = 0;
871                    if (!EnsureProviderIsOpen()) { return false; }
872                    try { provider.ReadFirstNonZeroByte(MemoryAddress, bytesToRead, out address); return true; }
873                    catch { address = 0x00; return false; }
874                }
875                #endregion
876                #region public virtual void ReadProcessMemory(int MemoryAddress, int bytesToRead, out int bytesRead, out byte[] data)
877                public virtual void ReadProcessMemory(int MemoryAddress, uint bytesToRead, out int bytesRead, out byte[] data)
878                {
879                    bytesRead = 0x00;
880                    data = new byte[] { };
881                    if (!EnsureProviderIsOpen()) { return; }
882                    try { provider.ReadProcessMemory(MemoryAddress, bytesToRead, out bytesRead, out data); }
883                    catch { bytesRead = 0x00; data = new byte[] { }; }
884                }
885                #endregion
886                #region IMemoryWriter members
887                #region public virtual void WriteProcessMemory(int MemoryAddress, byte byteToWrite, out int bytesWritten)
888                public virtual void WriteProcessMemory(int MemoryAddress, byte byteToWrite, out int bytesWritten)
889                {
890                    bytesWritten = 0;
891                    if (!EnsureProviderIsOpen()) { return; }
892                    try { provider.WriteProcessMemory(MemoryAddress, new byte[] { byteToWrite }, out bytesWritten); }
893                    catch { bytesWritten = 0x00; }
894                }
895                #endregion
896                #region public virtual void WriteProcessMemory(int MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
897                public virtual void WriteProcessMemory(int MemoryAddress, byte[] bytesToWrite, out int bytesWritten)
898                {
899                    bytesWritten = 0;
900                    if (!EnsureProviderIsOpen()) { return; }
901                    try { provider.WriteProcessMemory(MemoryAddress, bytesToWrite, out bytesWritten); }
902                    catch { bytesWritten = 0x00; }
903                }
904                #endregion
905                #endregion
906                #endregion
907                #region IFileWriter members
908                #region  public virtual bool WriteProcessMemoryToFile(string filename, int MemoryAddress, uint bytesToRead, out int bytesRead)
909                public virtual bool WriteProcessMemoryToFile(string filename, int MemoryAddress, uint bytesToRead, out int bytesRead)
910                {
911                    bytesRead = 0;
912                    if (!EnsureProviderIsOpen()) { return false; }
913                    try { provider.WriteProcessMemoryToFile(filename, MemoryAddress, bytesToRead, out bytesRead); return true; }
914                    catch
915                    { bytesRead = 0x00; return false; }
916                }
917                #endregion
918                #endregion
919            }
920            #endregion
921        }
922        #endregion
923  }  }

Legend:
Removed from v.250  
changed lines
  Added in v.251

  ViewVC Help
Powered by ViewVC 1.1.22