Wie funktionieren Pingbacks und wie kann man Pingbacks über .NET versenden?

image.png

Ganz technisch gesprochen: Pingbacks dienen der Benachrichtigung einer Seite, wenn diese auf einer anderen Seite verlinkt wird. Größtes (und einzigstes?) Einsatzgebiet ist in der Blogwelt zu finden. Ziel davon ist es, dass ein Autor benachrichtigt wird, wenn jemand über einen Artikel etwas schreibt. Meistens landet der Pingback mit in den Kommentaren.

Eine ältere Form davon sind die “Trackbacks”, allerdings sind diese scheinbar etwas aus der Mode gekommen. Hier ein Beispiel aus der Praxis (auf die Spam Thematik gehen wir dann noch ein)

image

Die Spezifikation & Konzept der Pingbacks

Auf dieser Seite gibt es die Spezifikation der Pingbacks zum Nachlesen. Pingbacks müssen vom “Pingback Empfänger” auch unterstützt werden.

Um die Sache einfacher zu Erklären hier ein Beispiel: Ich hab einen Artikel auf code-inside.de verfasst und jemand anderes schreibt über diesen Artikel und verlinkt diesen. Im Hintergrund der Blogengine (oder des “Quell-Systems”) läuft dann ungefähr folgendes Schema ab:

Zuerst wird geprüft ob die Zielseite Pingbacks unterstützt:

image

Hierbei wird einfach nur ein GET-Webrequest zum Ziel gemacht ohne besondere Parameter.

image

Als Antwort muss im Header X-Pingback angegeben sein – wenn nicht, dann unterstützt das Ziel keinen Pingback-Mechanismus.

 

image

Nun wird der eigentliche Pingback zur XMLRPC Schnittstelle geschickt. Dabei wird die URL aus dem Header genommen und ein XMLRPC Aufruf gemacht, welches so ein XML beinhaltet:

<?xml version="1.0" encoding="utf-16" standalone="yes"?>
<methodCall>
	<methodName>pingback.ping</methodName>
	<params>
		<param>
			<value><string>http://www.bizzbingo.com/what-is/ravendb</string></value>
		</param>
		<param>
			<value><string>http://code-inside.de/blog-in/2011/11/05/use-ravendb-as-embedded-filebase/</string></value>
		</param>
	</params>
</methodCall>

 

Überprüfung auf der Zielseite

Das Ziel (in meinem Beispiel also mein Blog), überprüft nun die Herkunft und ob diese Seite auch wirklich diesen Artikel verlinkt (ansonsten gibt es eine Fehlermeldung). Die Zielseite sucht sich dann (scheinbar) selbstständig ein Auszug von dem Aufrufer.

Pingbacks in .NET

Der Code stammt zu fast 100% aus dem Blogengine.NET Projekt, da ich selber erst nicht durch die Spezifikation durchgesehen hatte :)

namespace pingback.webapp.Controllers
{
    using System;
    using System.IO;
    using System.Net;
    using System.Text;
    using System.Xml;

    /// <summary>
    /// Sends pingbacks to website that the blog links to.
    /// </summary>
    public static class Pingback
    {
        #region Events

        /// <summary>
        ///     Occurs just before a pingback is sent.
        /// </summary>
        public static event EventHandler<EventArgs> Sending;

        /// <summary>
        ///     Occurs when a pingback has been sent
        /// </summary>
        public static event EventHandler<EventArgs> Sent;

        #endregion

        #region Public Methods

        /// <summary>
        /// Sends pingbacks to the targetUrl.
        /// </summary>
        /// <param name="sourceUrl">
        /// The source Url.
        /// </param>
        /// <param name="targetUrl">
        /// The target Url.
        /// </param>
        public static void Send(Uri sourceUrl, Uri targetUrl)
        {
            if (sourceUrl == null || targetUrl == null)
            {
                return;
            }

            try
            {
                var request = (HttpWebRequest)WebRequest.Create(targetUrl);
                request.Credentials = CredentialCache.DefaultNetworkCredentials;
                var response = (HttpWebResponse)request.GetResponse();
                string pingUrl = null;

                var pingUrlKeyIndex = Array.FindIndex(
                    response.Headers.AllKeys,
                    delegate(string k)
                        {
                            return k.Equals("x-pingback", StringComparison.OrdinalIgnoreCase) ||
                                   k.Equals("pingback", StringComparison.OrdinalIgnoreCase);
                        });

                if (pingUrlKeyIndex != -1)
                {
                    pingUrl = response.Headers[pingUrlKeyIndex];
                }

                Uri url;
                if (!string.IsNullOrEmpty(pingUrl) && Uri.TryCreate(pingUrl, UriKind.Absolute, out url))
                {
                    OnSending(url);
                    request = (HttpWebRequest)WebRequest.Create(url);
                    request.Method = "POST";

                    // request.Timeout = 10000;
                    request.ContentType = "text/xml";
                    request.ProtocolVersion = HttpVersion.Version11;
                    request.Headers["Accept-Language"] = "en-us";
                    AddXmlToRequest(sourceUrl, targetUrl, request);
                    var response2 = (HttpWebResponse)request.GetResponse();

                    string answer;
                    using (var sr = new StreamReader(response2.GetResponseStream()))
                    {
                        answer = sr.ReadToEnd();
                    }

                    response2.Close();

                    OnSent(url);
                }
            }
            catch (Exception ex)
            {
                ex = new Exception();

                // Stops unhandled exceptions that can cause the app pool to recycle
            }
        }

        #endregion

        #region Methods

        /// <summary>
        /// Adds the XML to web request. The XML is the standard
        ///     XML used by RPC-XML requests.
        /// </summary>
        /// <param name="sourceUrl">
        /// The source Url.
        /// </param>
        /// <param name="targetUrl">
        /// The target Url.
        /// </param>
        /// <param name="webreqPing">
        /// The webreq Ping.
        /// </param>
        private static void AddXmlToRequest(Uri sourceUrl, Uri targetUrl, HttpWebRequest webreqPing)
        {
            var stream = webreqPing.GetRequestStream();
            using (var writer = new XmlTextWriter(stream, Encoding.ASCII))
            {
                writer.WriteStartDocument(true);
                writer.WriteStartElement("methodCall");
                writer.WriteElementString("methodName", "pingback.ping");
                writer.WriteStartElement("params");

                writer.WriteStartElement("param");
                writer.WriteStartElement("value");
                writer.WriteElementString("string", sourceUrl.ToString());
                writer.WriteEndElement();
                writer.WriteEndElement();

                writer.WriteStartElement("param");
                writer.WriteStartElement("value");
                writer.WriteElementString("string", targetUrl.ToString());
                writer.WriteEndElement();
                writer.WriteEndElement();
                

                writer.WriteEndElement();
                writer.WriteEndElement();
            }
        }

        /// <summary>
        /// Called when [sending].
        /// </summary>
        /// <param name="url">The URL Uri.</param>
        private static void OnSending(Uri url)
        {
            if (Sending != null)
            {
                Sending(url, new EventArgs());
            }
        }

        /// <summary>
        /// Called when [sent].
        /// </summary>
        /// <param name="url">The URL Uri.</param>
        private static void OnSent(Uri url)
        {
            if (Sent != null)
            {
                Sent(url, new EventArgs());
            }
        }

        #endregion
    }
}

 

Die Anwendung ist auch recht einfach:

 

            // source must be available from the target url (e.g. localhost doesn´t work)
            string source = "http://www.bizzbingo.com/what-is/ravendb";

            // source must contain the target link... otherwise: Error.
            string target = "http://code-inside.de/blog-in/2011/11/05/use-ravendb-as-embedded-filebase/";
            Pingback.Send(new Uri(source), new Uri(target));

 

Die Response:

Je nachdem ob alles gut gegangen ist oder nicht, gibt die aufgerufenen Seite auch eine Antwort. Die kann z.B. im Fehlerfall so aussehen:

<?xml version="1.0"?>
<methodResponse>
  <fault>
    <value>
      <struct>
        <member>
          <name>faultCode</name>
          <value><int>17</int></value>
        </member>
        <member>
          <name>faultString</name>
          <value><string>The source URL does not contain a link to the target URL, and so cannot be used as a source.</string></value>
        </member>
      </struct>
    </value>
  </fault>
</methodResponse>

 

Oder im besten Fall so:

<?xml version="1.0"?>
<methodResponse>
  <params>
    <param>
      <value>
      <string>Pingback from http://www.bizzbingo.com/what-is/ravendb to http://code-inside.de/blog-in/2011/11/05/use-ravendb-as-embedded-filebase/ registered. Keep the web talking! :-)</string>
      </value>
    </param>
  </params>
</methodResponse>

 

Die Fehlercodes finden sich auch in der Spezifikation wieder.

Problematisch: Spam

Pingbacks sind vom Prinzip her eine gute Sache, können allerdings leicht ausgenutzt werden, daher werden Sie entweder durch Blogspam-Filter (wie Akismet) herausgefiltert oder gar nicht mehr angezeigt. Spammer nutzen gerne diese Schnittstelle um Links auf allen möglichen Seiten abzulegen. Mein Blogtemplate z.B. zeigt keine Pingbacks an. Vermutlich muss die Quelle erst einen gewissen Grad an Reputation haben um nicht mehr als Spam für Akismet & co. zu gelten.

[ Code @ Google Code ]

Wenn dir der Blogpost gefallen hat, dann hinterlasse doch einen Kommentar. Wenn du auf dem Laufenden bleiben willst, abonniere unseren RSS Feed oder folge uns auf Twitter.

About the author

Written by

Hi, ich bin Robert Mühsig und bin Webentwickler und beschäftige mich mit Web-Frameworks auf dem Microsoft Web Stack und scheue mich auch nicht vor Javascript. Der Blog begann als "Problemsammelstelle und Lösungshilfe" und seitdem schreibe ich hier alles auf. Seit 2008 bin ich Microsoft MVP für ASP.NET. Treffen kann man mich online via Twitter (@robert0muehsig) oder hier.

One Response

  1. guter Beitrag!

    Reply

Comment on this post

Letzte Posts

  • image.png
    Azure AppInsights: Ein mini Google Analytics für Websites

    Seit der Build Konferenz ist das neue Azure Portal für alle freigeschaltet. Durch das neue Portal ist mir ein “Dienst” aufgefallen, den ich bisher nicht gesehen hatte: Azure Application Insights Viel weiss ich nicht über den Dienst, aber wer eine Azure Website hat der sollte mal die “Analytics” Box öffnen. Im Grunde handelt es sich […]

  • image.png
    Source Code veröffentlichen – aber bitte mit Lizenz

    Seit es den Blog gibt wird auch meist der gesamte Demo Source Code mit veröffentlicht. Das Ganze hatte ich am Anfang noch als .zip verteilt, später lag es mal auf Google Code und nun liegen alle Samples und sonstige Sachen auf GitHub. Beim letzten User Group Treffen in Zürich mit dem Titel “Open Source: Get […]

  • Fix: Cannot convert from ‘CConnectProxy::_ComMapClass *’ to ‘AddInDesignerObjects::IDTExtensibility2 *’

    Mal einen etwas esoterischer Blogpost, welcher auftaucht wenn man zu viel mit Office Addins rumspielt. Der Fehler passiert beim Bauen von C++ Projekten, welchen diesen Typ benötigen. Lösung (auf 64bit Systemen): C:\Program Files (x86)\Common Files\DESIGNER>regsvr32 MSADDNDR.DLL And Rebuild. Meine lieben Kollegen hatte mir dies schon mehrfach gesagt, allerdings hatte ich es immer wieder vergessen Das […]

  • Gegen das Gesetz verstoßen: X Jahre Haft. Gegen die Terms of Use verstoßen: Bann auf Lebenszeit. Danke Google & co.

    Bei fast allen Diensten die man im Internet nutzen kann muss man den “Terms of use” zustimmen. Völlig logisch dass da natürlich drin steht was erlaubt und was nicht. Wenn man gegen diese Regelungen verstößt hat das Unternehmen natürlich das Recht etwas dagegen zu unternehmen. In der heutigen Welt beherrschen einige wenige Unternehmen die digitale […]

  • image.png
    RSS Feed samt Kommentaranzahl und andere nicht Standard Elemente mit dem SyndicationFeed auslesen

    Jetzt mal ein Blogpost ohne ein fancy NuGet Package: Seit .NET 3.5 gibt es die SyndicationFeed Klasse. Eine schon etwas ältere API, reicht aber aus um Atom bzw. RSS Feeds zu lesen. In diversen RSS Feeds gibt es aber Erweiterungen, welche man natürlich auch auslesen möchte. So gibt WordPress z.B. auch die Anzahl der geposteten […]

Amazon Shop

Facebook