Manuel Kukla's Blog

IT, Finanzen, Aktien, Kuriositäten und alltägliches

Einige PInvoke-Signaturen für dnsapi.dll

Kürzlich hatte ich das Bedürfnis meinem VPN-Client die Registrierung im DNS-Server beizubringen. Nachdem ein ipconfig /registerdns nicht zum Ziel führte (funktioniert anscheinend nicht für VPN-Adapter, oder nicht übers VPN, oder nicht mit den DHCP-Addressen vom VPN-Server, oder nur für den ersten DNS-Server, oder wie auch immer...) musste eine andere Lösung her.

Die Aufgabenstellung lautet: Einen DNS-Eintrag am internen DNS-Server im Remote-Netzwerk anlegen bzw. aktualisieren.

Deshalb kam ich in Verlegenheit dies selbst zu implementieren. Bald bin ich über die DnsQuery-Funktion gestolpert, welche jedoch ziemlich bescheiden dokumentiert ist. Wie ich dazu kam? Auf Codeproject gab es ein Projekt, welches das ganze via Extended T-SQL-Procedure macht. (http://www.codeproject.com/Articles/5535/Dynamic-DNS-Web-Service) Tja, "... It's not rocket science ..." dachte ich mir, wenn das mit einer extended-SP hinhaut. Leider war die halt nativ und benötigt keine PInvokes...

Ich war also auf der Suche nach den korrekten Deklarationen für C# für folgende Funktionen:

DnsQuery (bzw. DnsQuery_W)
DnsModifyRecordsInSet (bzw. DnsModifyRecordsInSet_W) DnsAcquireContextHandle (bzw. DnsAcquireContextHandle_W) DnsReleaseContextHandle

Die Basis dafür war die pinvoke.net-Seite, welche jedoch wie schon des öfteren bemerkt bestensfalls 80% der Lösung liefert und man die restlichen 20% hart erfrickeln muss. (http://www.pinvoke.net/default.aspx/dnsapi.dnsquery)

Nachdem ich nun die richtige Lösung für (mein) Problem gefunden habe, möchte ich es gerne für andere (und natürlich auch für mich :-)) archivieren.

    [DllImport("dnsapi", EntryPoint = "DnsQuery_W", CharSet = CharSet.Unicode, SetLastError = true, ExactSpelling = true)]
    public static extern int DnsQuery([MarshalAs(UnmanagedType.VBByRefStr)] ref string lpstrName, //_In_        PCTSTR      lpstrName,
                                       DnsRecordTypes wType,                                      //_In_        WORD        wType,      //Enum
                                       DnsQueryOptions Options,                                   //_In_        DWORD       Options,    //[Flags] Enum
                                       IntPtr pExtra,                                             //_Inout_opt_ PVOID       pExtra,
                                       ref IntPtr ppQueryResultsSet,                              //_Out_opt_   PDNS_RECORD *ppQueryResultsSet,
                                       IntPtr pReserved);                                         //_Out_opt_   PVOID       *pReserved

    [DllImport("dnsapi.dll", EntryPoint = "DnsModifyRecordsInSet_W", CharSet = CharSet.Unicode, SetLastError = false, ExactSpelling = true)]     public static extern int DnsModifyRecordsInSet(IntPtr pAddRecords, IntPtr pDeleteRecords, int Options, IntPtr hContext, IntPtr pExtra, IntPtr pReserved);     [DllImport("dnsapi.dll", EntryPoint = "DnsAcquireContextHandle_W", CharSet = CharSet.Unicode, SetLastError = true, ExactSpelling = true)]     public static extern int DnsAcquireContextHandle(int credentialsFlags, [InMarshalAs(UnmanagedType.LPStruct)] DnsApi.SecWinNtAuthIdentity credentials, out IntPtr handle);     [DllImport("dnsapi.dll", EntryPoint = "DnsReleaseContextHandle", CharSet = CharSet.Unicode, SetLastError = false, ExactSpelling = true)]     public static extern void DnsReleaseContextHandle(IntPtr handle);

    [DllImport("dnsapi.dll", CharSet = CharSet.Auto, SetLastError = true)]     public static extern void DnsRecordListFree(IntPtr pRecordList, DNS_FREE_TYPE FreeType);

Die structs
DnsQueryOptions, DnsUpdateOptions, DnsRecordTypes
können von der pinvoke-Seite übernommen werden.

Wichtig ist hingegen die korrekte Deklaration von DNS_RECORD, welche wie folgt aussieht. Ganz wichtig ist hier Charset.Unicode, da sonst nur das erste Zeichen des Strings vorhanden ist, und ein Update des Eintrags nicht funktioniert.
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct DNS_RECORD
    {
      public IntPtr pNext;
      public string pName;
      public short wType;
      public short wDataLength;
      public int flags;
      public int dwTtl;
      public int dwReserved;
      public DnsData DATA;
      public short wPreference;
      public short Pad;
      private int Pad1;
      private int Pad2;
      private int Pad3;
      private int Pad4;
      private int Pad5;
      private IntPtr Pad6;
      private IntPtr Pad7;
      private IntPtr Pad8;
    }
 Ebenfalls wichtig ist, dass der Record nicht bei Pad aufhört, sondern dahinter auch noch Pad1-Pad8 kommt. (Quelle: http://stackoverflow.com/questions/6662381/how-to-update-some-com-marshalling-code-to-work-on-a-64-bit-system)

Der Aufruf für DnsQuery funktioniert dann wie folgt. Ich verwende als 4. Parameter ein Array von IPs, welche die befragten DNS-Server darstellen. (Dies ist u.a. hier dokumentiert: https://support.microsoft.com/en-us/kb/831226, jedoch nicht im offiziellen Artikel zur Funktion: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682016%28v=vs.85%29.aspx)

        String domain = "www.mku.name";
        
//Anfrage an spezifischen DNS-Server (strDNSIP) richten uint address = BitConverter.ToUInt32(IPAddress.Parse(strDNSIP).GetAddressBytes(), 0);         uint[] ipArray = new uint[1];         ipArray.SetValue(address, 0);         DnsIntf.IP4_ARRAY dnsServerArray = new DnsIntf.IP4_ARRAY();         dnsServerArray.AddrCount = 1;         dnsServerArray.AddrArray = new uint[1];         dnsServerArray.AddrArray[0] = address;         IntPtr ptrDNSServer = Marshal.AllocHGlobal(Marshal.SizeOf(dnsServerArray));         Marshal.StructureToPtr(dnsServerArray, ptrDNSServer, false);         var result = DnsIntf.DnsQuery(ref domain, DnsIntf.DnsRecordTypes.DNS_TYPE_ALL, DnsIntf.DnsQueryOptions.DNS_QUERY_BYPASS_CACHE, ptrDNSServer, ref recordsArray, IntPtr.Zero);
Die Ergebnisse können wie folgt durchlaufen werden:
        DnsIntf.DNS_RECORD record = new DnsIntf.DNS_RECORD();
        var recordList = new List<string>();
        for (var recordPtr = recordsArray; !recordPtr.Equals(IntPtr.Zero); recordPtr = record.pNext)
        {
          record = (DnsIntf.DNS_RECORD)Marshal.PtrToStructure(recordPtr, typeof(DnsIntf.DNS_RECORD));
          if (record.wType == (int)DnsIntf.DnsRecordTypes.DNS_TYPE_A)
          {
            IPAddress addr = DnsIntf.ConvertUintToIpAddress(record.DATA.A.IpAddress);
            recordList.Add(addr.ToString());
          }
        }

Die IP zu uint-Konvertierung erfolgt mit dieser Funktion. Ich habe hier noch ein Array.Reverse eingebaut, weil es in meinem Fall genau verkehrt herum war. Bei Nicht-Funktionieren anpassen, ich hab nichts zum Gegentesten ;-)
 public static IPAddress ConvertUintToIpAddress(uint ipAddress)
    {
      // x86 is in little endian
      // Network byte order (what the IPAddress object requires) is big endian
      // Ex - 0x7F000001 is 127.0.0.1
      var addressBytes = new byte[4];
      addressBytes[0] = (byte)((ipAddress & 0xFF000000u) >> 24);
      addressBytes[1] = (byte)((ipAddress & 0x00FF0000u) >> 16);
      addressBytes[2] = (byte)((ipAddress & 0x0000FF00u) >> 8);
      addressBytes[3] = (byte)(ipAddress & 0x000000FFu);
 
      if (BitConverter.IsLittleEndian) // korrekt?
        Array.Reverse(addressBytes);
 
      return new IPAddress(addressBytes);
    }

Ein neuer A-Record mit TTL 10s kann (etwas russisch^^) wie folgt erzeugt werden:

        DnsIntf.DNS_RECORD recordNew = new DnsIntf.DNS_RECORD();
        recordNew.dwTtl = 10;
        recordNew.pName = domain;
        recordNew.DATA.A.IpAddress = BitConverter.ToUInt32(newIPaddr.GetAddressBytes(), 0);
        recordNew.wDataLength = 4;
        recordNew.wType = 1;
        recordNew.flags = 8201;

Zum Aktualisieren des Eintrags wird ein Domänen-User benötigt -> Es muss der richtige Kontext erzeugt werden:
IntPtr ptrContext = new IntPtr();
var resultContext = DnsIntf.DnsAcquireContextHandle(1 /*TRUE for UNICODE*/new DnsApi.SecWinNtAuthIdentity(strUser, strDomain, strPwd), out ptrContext);
SecWinNtAuthIdentity ist wie folgt definiert. Quelle: https://searchcode.com/codesearch/view/12799292/

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public class SecWinNtAuthIdentity
    {
      public string User;
      public int UserLength;
 
      public string Domain;
      public int DomainLength;
 
      public string Password;
      public int PasswordLength;
 
      public uint Flags;
 
      public SecWinNtAuthIdentity(string user, string domain, string password)
      {
        User = user;
        UserLength = user != null ? user.Length : 0;
 
        Domain = domain;
        DomainLength = domain != null ? domain.Length : 0;
 
        Password = password;
        PasswordLength = password != null ? password.Length : 0;
 
        Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
      }
    }


Und dann noch zu guter Letzt das Aktualisieren des Eintrags. Das funktioniert so, dass eine (via pNext verkettete) Liste von Neuen sowie zu löschenden Einträgen übergeben werden muss. Im konkreten Fall ptrNew (welcher aus recordNew erzeugt wird), sowie recordsArray aus der oben durchgeführten Abfrage.

IntPtr ptrNew = Marshal.AllocHGlobal(Marshal.SizeOf(recordNew));
Marshal.StructureToPtr(recordNew, ptrNew, false);
 
IntPtr ptrOut = new IntPtr();
var result2 = DnsIntf.DnsModifyRecordsInSet(ptrNew, recordsArray, (int)DnsIntf.DnsUpdateOptions.DNS_UPDATE_SECURITY_USE_DEFAULT, ptrContext, ptrDNSServer, ptrOut);

Am Schluss sollte man noch etwas aufräumen:
 if (recordsArray != IntPtr.Zero)
 {
     DnsIntf.DnsRecordListFree(recordsArray, DnsIntf.DNS_FREE_TYPE.DnsFreeFlat);
 }
Vermutlich gibt es auch noch etwas anderes zu bereinigen, aber das hebe ich mir fürs Neue Jahr auf :-) Die Saubermacher unter den Lesern dürfen gerne in den Kommentaren posten.


Mein "Addon" für Brokerjet...

Ich bin seit längerem Kunde bei Brokerjet.at und verwende dort den "WebTrader" als Trading-Plattform. Diese ist eigentlich nicht schlecht, jedoch gibt es einen großen Minuspunkt: Man hat in der Depotansicht keinerlei Überblick, welche Aktie in der letzten Zeit gut gelaufen ist, und wo es gerade bröselt.

Nehmen wir hier als Beispiel eine meiner Lieblings-Depotleichen: Ein ETF auf den "ARCA GOLD BUGS"-Index, zu sehen in meiner Standard-Depotansicht: 

Hier sieht man, dass die Position derzeit etwa 13,8% im Minus liegt - schön und gut, wenn man weiß, dass sie auch schon Mal viel schlimmer dastand - das weiß ich jedoch nicht bei jeder Einzelnen meiner derzeit etwa 20 Positionen.

Ein aktuelles Chart erhält man via http://www.finanzen.net/etf/ComStage_NYSE_Arca_Gold_BUGS_UCITS_ETF welches dann folgendes Bild zutage bringt:

     

 

Man beachte, dass Finanzen.net den Preis in USD angibt. Aber auf boerse-frankfurt.de gibt es auch ein Chart in EUR.(http://www.boerse-frankfurt.de/de/etfs/comstage+nyse+arca+gold+bugs+ucits+etf+etf+LU0488317701)

Je nach Art und Weise der Teesud-Leserei und Skalierung, könnte man hier auch einen beginnenden Aufwärtstrend sehen - schön und gut - die Spitze im Februar 2015 inkl. einem möglichen Ausstiegszeitpunkt ist mir jedoch komplett entgangen.

 

Ich hoffe dass das Problem soweit erklärt ist - die Lösung beginnt mit einem kleinen "Wrapper" mit C# und dem Webbrowser-Control. Ich werde in den folgenden Absätzen die Lösung etwas erklären und die kleinen Herausforderungen darstellen. Source-Code werde ich vorerst keinen veröffentlichen - den gibt es möglicherweise nach individueller Anfrage bei mir :-)

 

Herausforderungen:

  • Automatischer Login im Depot - nur so können zuverlässig Kursdaten gesammelt werden.
  • Auslesen der Kursdaten aus dem HTML
  • iFrame-Konstrukte auf der Seite
  • Weiterleitungen während des Logins und auch später
  • Skriptfehler
  • Auswertung

 Automatischer Login im Depot

Finden der beiden Felder im Webbrowser für Username und Passwort, sowie Befüllen dieser mittels:

webBrowser.Document.GetElementById("Feldname").InnerText = "Wert";

Sofern die Felder befüllt sind, kann das Formular abgesendet werden. Dazu wird einfach das JavaScript ausgeführt:

object y = webBrowser.Document.InvokeScript("window.opener.refreshAfterPopupLogin()");

 

Auslesen der Kursdaten aus dem HTML

Sofern man über das Login zur richtigen Depotseite gekommen ist, geht's ans Auslesen der Daten. Hierfür empfiehlt sich ein Splitten der Tabellen nach Zeilen, und dann nach Spalten:

String[] sSplitLine = s.Split(new String[] { "<tr>""</tr>" }, StringSplitOptions.None);
String[] sSplitCols = sLine.Split(new String[] { "<td>""</td>" }, StringSplitOptions.None);

Anschließend müssen nur noch die minimalen HTML-Formatierungen entfernt werden, und die Daten lassen sich schon recht Schnell in eine Datenbank verpacken. Als Ausgangspunkt kann hier folgende DB-Struktur dienen:

CREATE TABLE [dbo].[PreisInfo](
  [PreisInfoId] [int] IDENTITY(1,1) NOT NULL,
   [Name] [nvarchar](100) NULL,
   [ISIN] [nvarchar](12) NULL,
   [Menge] [decimal](18, 3) NULL,
   [LetzterKurs] [decimal](18, 3) NULL,
   [DurchKaufpreis] [decimal](18, 3) NULL,
   [Marktwert] [decimal](18, 3) NULL,
   [PerformanceInkl] [decimal](18, 3) NULL,
   [PerformanceExkl] [decimal](18, 3) NULL,
   [Ertrag] [decimal](18, 3) NULL,
   [per] [datetime] NULL
) ON [PRIMARY] 

 iFrame-Konstrukte auf der Seite

 Nachdem ich die Daten-Auslesefunktion fertig hatte, und meine ersten Daten aus dem HTML-Source in die Datenbank übertragen hatte, kam ich noch auf ein recht nerviges Sicherheitsproblem: Auf der Seite werden iFrames mit verschiedenen Domains verwendet - hier schlägt der IE mit einer UnauthorizedAccessException zu, wenn man auf das Document zugreifen möchte. Die einfache Lösung ist die Umgehung der Frames, und Aufruf der direkten Unterseite. Wenn dies nicht funktioniert, kann man via http://stackoverflow.com/questions/10645143/webbrowsercontrol-unauthorizedaccessexception-when-accessing-property-of-a-fram einen CrossFrame-Zugriff versuchen - mir ist dieser jedoch nicht gelungen. Ich habe mich dann aus Zeitgründen für die einfachere Lösung entschieden.

Weiterleitungen während des Logins und auch später 

Leider besteht der Login bei Brokerjet aus mehreren Weiterleitungen - dies lässt sich am besten im DocumentCompleted-Event des Webbrowsers mit einem if behandeln:

if (e.Url.ToString().EndsWith("MySite.html"))

Skriptfehler

 Der eingebettete IE (WebBrowser) wirft gerne Skriptfehler. Dies lässt sich mit folgender Zeile abschalten:

webBrowser.ScriptErrorsSuppressed = true;

Auswertung

Gibt es für einen Programmierer etwas schöneres als korrekt aufbereitete, rohe SQL-Daten? Ja, klar - eine bereits fertige Statistik. Aber wer traut denn schon fremden Statistiken? ^^

Also zurück zum Start, ein bisschen Datum-Frickeln und ein paar Joins später kommt man auf folgendes Select:

 

DECLARE @VortagBeginn datetime
DECLARE @HeuteEnde datetime
SET @VortagBeginn = convert(nvarchar(20), dateadd(d, -1, getdate()), 104) + ' 00:00:00'
SET @HeuteEnde = convert(nvarchar(20), getdate(), 104) + ' 23:59:59'
SELECT @VortagBeginn as Von, @HeuteEnde as Bis
 
SELECT x.ISIN, PMin.Name, 
       PMin.LetzterKurs Kurs1,
       PMin.Marktwert Wert1,
       PMin.per Datum1, 
       PMax.LetzterKurs Kurs2,
       PMax.Marktwert Wert2,
       PMax.per Datum2,
       PMax.Marktwert - PMin.Marktwert as Diff,
       cast(ROUND((PMax.LetzterKurs-PMin.LetzterKurs) / PMin.LetzterKurs * 100, 2) as decimal(18,2)) as Veraenderung
			FROM 
			(
				SELECT ISIN, Min(PreisInfoId) as MinPreisInfoId, Max(PreisInfoId) as MaxPreisInfoId
				FROM PreisInfo
				WHERE per BETWEEN @VortagBeginn AND @HeuteEnde
				GROUP BY ISIN
			) x
			INNER JOIN PreisInfo PMin ON PMin.PreisInfoId = x.MinPreisInfoId
			INNER JOIN PreisInfo PMax ON PMax.PreisInfoId = x.MaxPreisInfoId        
			

Was nun folgendes Ergebnis liefert:

 

-> Seit gestern etwa 3,2% und 170€ Gewinn - sehr schön. Kluge Leute bemerken sicher, dass ich bei diesem Screenshot zu wenig entfernt habe. Aber wer sich die Arbeit macht, dem sei die Information gegönnt.

In diesem Sinne wünsche ich euch noch ein schönes Wochenende. Fehlersuche und Feedback ist natürlich gerne erwünscht.