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)
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:
Hierbei wird einfach nur ein GET-Webrequest zum Ziel gemacht ohne besondere Parameter.
Als Antwort muss im Header X-Pingback angegeben sein – wenn nicht, dann unterstützt das Ziel keinen Pingback-Mechanismus.
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>https://blog.codeinside.eu-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 = "https://blog.codeinside.eu-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 https://blog.codeinside.eu-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.
