Grupo de Snippets parte del Artículo: "Crea tu Propio Repositorio de Extensiones Pagas para WordPress" ubicado en http://es.8elite.com/2012/11/05/crea-tu-propio-repositorio-de-extensiones-pagas-para-wordpress/

api-clase.php

<?php
/**
 * Autor: L'Elite de José SAYAGO
 * URL: http://laelitenetwork.com
 * Licencia: GNU General Public License 2.0 (GPL) http://www.gnu.org/licenses/gpl.html
 * Fichero: mi-extension-wordpress-api.php
 * Clase para la API de actualización de la extensión
 */
class api_actualizacion {
     // Versión actual
     public $version_actual;
     // URL de la API
     public $url_api;
     // Ruta de la extensión
     public $fichero_principal;
     // Slug de la extensión
     public $slug_extension;
     // Licencia de usuario
     public $licencia_usuario;
     /**
      * Inicializar una nueva instancia de la clase de actualización
      * automática de WordPress
      * @param string $version_actual
      * @param string $url_api
      * @param string $slug_extension
      * @param string $fichero_principal
      * @param string $licencia_usuario
      */
     function __construct($version_actual,$url_api,$slug_extension,$fichero_principal,$licencia_usuario) {
          $this->version_actual = $version_actual;
          $this->url_api = $url_api;
          $this->slug_extension = $slug_extension;
          $this->fichero_principal = $fichero_principal;
          $licencia = htmlspecialchars( $licencia_usuario );
          $this->licencia_usuario = $licencia;
          // Verificar licencia
          if( $this->verificar_licencia( $licencia ) == 'true' ) {
               // Verificación de actualizaciones de WordPress
               add_filter( 'pre_set_site_transient_update_plugins', array( $this, 'verificar_actualizacion' ) );
               // Respuesta
               add_filter( 'plugins_api', array( $this, 'verificar_informacion' ), 10, 3 );
          }
     }

     /**
      * Filtro de actualización
      * @param transient
      * @return transient object
      */
     public function verificar_actualizacion( $transient ) {
          // Revisar si no se han buscado actualizaciones
          if( empty( $transient->last_checked ) ) {
               return $transient;
          }
          // Obtener la versión de nuestra extensión desde el servidor
          $version_servidor = $this->version_servidor();
          $version_servidor = htmlspecialchars( $version_servidor[0]['version_actual'] );
          $licencia_usuario = htmlspecialchars( $this->licencia_usuario );
          // Validar licencia
          if( $this->verificar_licencia( $licencia_usuario ) === 'true' ) {
               // Verificar si el usuario posee una licencia que le permita actualizar
               if( $this->comprobar_acceso( $licencia_usuario, $version_servidor ) === 'true' ) {
                    // Verificar si hay una nueva versión y hacer algo en base a ello
                    if( version_compare( $this->version_actual, $version_servidor, '<' ) ) {
                         // Crear objeto para mostrar información de actualización
                         $mi_obj = new stdClass();
                         $mi_obj->slug = $this->slug_extension;
                         $mi_obj->new_version = $version_servidor;
                         $mi_obj->url = $this->url_api;
                         $mi_obj->package = $this->url_api.'?codigo='.$this->licencia_usuario.'&version='.MiExtension_Version;
                         // Completar el objeto transient con nuestros datos
                         $transient->response[$this->fichero_principal] = $mi_obj;
                    }
                    return $transient;
               } else {
                    // Notificar al usuario que debe hay una nueva versión
                    add_action( 'admin_notices', 'notifica_actualizacion' );
               }
          } else {
               // Notificar al usuario que active su copia
               add_action( 'admin_notices', 'configuracion_requerida' );
          }
     }

     /**
      * Filtro de descripción
      * @param boolean $false
      * @param array $action
      * @param object $arg
      * @return boolean | object
      */
     public function verificar_informacion( $false, $action, $arg ) {
          // Obtener información de nuestra extensión
          if( @$arg->slug === $this->slug_extension ) {
               $informacion = $this->informacion_servidor();
               return $informacion;
          }
          return $false;
     }

     /**
      * Obtener versión desde el servidor
      * @return string versión de la extensión
      */
     public function version_servidor() {
          $consulta = wp_remote_post( $this->url_api, array('body' => array( 'que_consultar' => 'version' ) ) );
          if( !is_wp_error( $consulta ) || wp_remote_retrieve_response_code( $consulta ) === 200 ) {
               return unserialize( $consulta['body'] );
          }
          return false;
     }

     /**
      * Obtener información de la extensión desde el servidor
      * @return bool | object
      */
     public function informacion_servidor() {
          $consulta = wp_remote_post( $this->url_api, array('body' => array( 'que_consultar' => 'info' ) ) );
          if( !is_wp_error( $consulta ) || wp_remote_retrieve_response_code( $consulta ) === 200 ) {
               return unserialize( $consulta['body'] );
          }
          return false;
     }

     /**
      * Comprobar licencia de usuario
      * @var string licencia de usuario
      * @return boolean
      */
     public function verificar_licencia( $licencia ) {
          $consulta = wp_remote_post( $this->url_api, array( 'body' => array( 'que_consultar' => 'licencia', 'codigo' => $licencia, 'version' => MiExtension_Version ) ) );
          if( !is_wp_error( $consulta ) || wp_remote_retrieve_response_code( $consulta ) === 200 ) {
               return $consulta['body'];
          }
          return false;
     }

     /**
      * Comprobar que la licencia tiene derecho a actualizar
      * @var string licencia de usuario
      * @return boolean
      */
     public function comprobar_acceso( $licencia, $version_servidor ) {
          $consulta = wp_remote_post( $this->url_api, array( 'body' => array( 'que_consultar' => 'comparar_versiones', 'codigo' => $licencia, 'version_servidor' => $version_servidor ) ) );
          if( !is_wp_error( $consulta ) || wp_remote_retrieve_response_code( $consulta ) === 200 ) {
               return $consulta['body'];
          }
          return false;
     }
}
?>

api-index.php

<?php
/**
 * Fichero: index.php
 * Este fichero debe ser accesible a través de la dirección http://api.miservidor.com/
 */
// Llamar la clase de la base de datos
require_once 'clase_bd.php';
// Creamos un objeto
$bd = new baseDatos();
// Preparar la captura de variables POST
@$accion = htmlspecialchars( $_POST['que_consultar'] );
@$licencia = htmlspecialchars( $_POST['codigo'] );
@$version_servidor = htmlspecialchars( $_POST['version_servidor'] );
// Evaluar las llamadas
if( !empty( $accion ) ) {
     switch( $accion ) {
          // Consultar versión
          case 'version':
               $consulta = array(
                    'tabla' => 'api_extension',
                    'campo' => array( 'version_actual' )
               );
               $version_actual = $bd->consultar( $consulta );
               echo serialize( $version_actual );
               break;
          // Consultar información
          case 'info':
               $consulta = array(
                    'tabla' => 'api_extension',
                    'campo' => array(
                         'version_actual',
                         'version_wordpress',
                         'version_probada',
                         'calificacion',
                         'votos',
                         'descargas',
                         'ultima_actualizacion',
                         'descripcion',
                         'instalacion',
                         'faq',
                         'cambios'
                    )
               );
               $resultados = $bd->consultar( $consulta );
               $mi_obj = new stdClass();
               $mi_obj->slug = 'mi-extension-wordpress';
               $mi_obj->new_version = $resultados[0]['version_actual'];
               $mi_obj->requires = $resultados[0]['version_wordpress'];
               $mi_obj->tested = $resultados[0]['version_probada'];
               $mi_obj->rating = $resultados[0]['calificacion'];
               $mi_obj->num_ratings = $resultados[0]['votos'];
               $mi_obj->downloaded = $resultados[0]['descargas'];
               $mi_obj->last_updated = $resultados[0]['ultima_actualizacion'];
               $mi_obj->sections = array(
                    'description' => nl2br( $resultados[0]['descripcion'] ),
                    'installation' => nl2br( $resultados[0]['instalacion'] ),
                    'faq' => nl2br( $resultados[0]['faq'] ),
                    'changelog' => nl2br( $resultados[0]['cambios'] )
               );
               $mi_obj->download_link = 'http://api.miservidor.com/';
               echo serialize( $mi_obj );
               break;
          // Consultar licencia
          case 'licencia':
               if( !empty( $licencia ) ) {
                    $consulta = array(
                         'tabla' => 'licencias_usuarios',
                         'donde' => "licencia = '$licencia'"
                    );
                    if( $bd->consultar_licencia( $consulta ) ) {
                         echo 'true';
                    } else {
                         echo 'false';
                    }
               } else {
                    echo 'false';
               }
               break;
          // Comparar versiones
          case 'comparar_versiones':
               if( !empty( $licencia ) && !empty( $version_servidor ) ) {
                    $consulta = "SELECT id FROM licencias_usuarios WHERE licencia = '$licencia' AND version >= '$version_servidor'";
                    if( $bd->ejecuta_consulta( $consulta ) ) {
                         echo 'true';
                    } else {
                         echo 'false';
                    }
               }
               break;
     }
} else {
     // Ha sido llamado desde WordPress para actualizar
     $licencia = htmlspecialchars( $_GET['codigo'] );
     $version = htmlspecialchars( $_GET['version'] );
     // Si hay datos
     if( !empty( $licencia ) && !empty( $version ) ) {
          // Consultar si la licencia y la versión tienen acceso
          $consulta = "SELECT id FROM api_extension WHERE licencia = '$licencia' AND version = '$version'";
          if( $bd->ejecuta_consulta( $consulta ) ) {
               $consulta_datos = array(
                    'tabla' => 'api_extension',
                    'campo' => 'version_actual',
                    'donde' => NULL
               );
               $version_actual = $bd->obtener_datos( $consulta_datos );
               // Obtener la ruta de la versión actual
               if( !empty( $version_actual ) ) {
                    $consultar_ruta = array(
                         'tabla' => 'archivos_extension',
                         'campo' => 'ruta_archivo',
                         'donde' => "version = '$version_actual'"
                    );
                    $ruta_archivo = $bd->obtener_datos( $consultar_ruta );
               }
               if( !empty( $ruta_archivo ) ) {
                    // Generar un fichero para el usuario
                    if( copy( $ruta_archivo, "tmp/mi-extension-wordpress-".$licencia.".zip" ) ) {
                         header('Cache-Control: public');
                         header('Content-Description: File Transfer');
                         header('Content-Type: application/zip');
                         header('Content-Disposition: attachment; filename="mi-extension-wordpress.zip"');
                         readfile( "tmp/mi-extension-wordpress-".$licencia.".zip" );
                    }
               }
          }
     } else {
          // Nada que hacer
          die;
     }
}
?>

clase-bd.php

<?php
/*
 * Fichero: clase_bd.php
 * Clase para consultar la Base de Datos
 */
// Incluir la librería AdoDB5
define( 'ADODB5', 'adodb5/', true );
require_once( ADODB5 . 'adodb.inc.php' );
require_once( ADODB5 . 'adobd-exceptions.inc.php' );
// Datos de conexión a la BD
define( 'NOMBRE_BD', '' );
define( 'USUARIO_BD', '' );
define( 'CONTRASENA_BD', '' );
define( 'SERVIDOR_BD', '' );
class baseDatos {
     // Conectar con la BD
     function basedatos() {
          $dsn = 'mysql://' . USUARIO_BD . ':' . CONTRASENA_BD . '@' . SERVIDOR_BD . '/' . NOMBRE_BD . '?persist';
          $conn = ADONewConnection( $dsn );
          $this->conn = &$conn;
     }
     // Consultas
     public function consultar( $consulta ) {
          // Arreglo
          if( !empty( $consulta ) ) {
               $tabla = htmlspecialchars( $consulta['tabla'] );
               $cuenta_campos = count( $consulta['campo'] );
               if( $cuenta_campos > 1 ) {
                    for( $i = 0; $i < $cuenta_campos; $i++ ) {
                         $campos .= '`' . htmlspecialchars( $consulta['campo'][$i] ) . '`,';
                    }
                    // Eliminar última coma
                    $campos = substr_replace( $campos, "", -1 );
               } else {
                    $campos = '`' . htmlspecialchars( $consulta['campo'][0] ) . '`';
               }
               $sql = "SELECT $campos FROM $tabla";
               $respuesta = $this->conn->Execute( $sql );
               // Verificar respuesta
               if( $this->conn->Affected_Rows( $respuesta ) < 1 ) {
                    // No se encontró nada
                    return false;
               } else {
                    while( !$respuesta->EOF ) {
                         $resultados[] = $respuesta->fields;
                         $respuesta->MoveNext();
                    }
                    return $resultados;
               }
          } else {
               // Nada que hacer
               return false;
          }
     }
     // Consultar licencia
     public function consultar_licencia( $consulta ) {
          if( !empty( $consulta ) ) {
               $tabla = htmlspecialchars( $consulta['tabla'] );
               $donde = htmlspecialchars( $consulta['donde'] );
               $sql = "SELECT id FROM $tabla WHERE $donde";
               $respuesta = $this->conn->Execute( $sql );
               // Verificar respuesta
               if( $this->conn->Affected_Rows( $respuesta ) < 1 ) {
                    return true;
               } else {
                    return false;
               }
          } else {
               // Nada que hacer
               return false;
          }
     }
     // Obtener datos
     public function obtener_datos( $consulta ) {
          $tabla = htmlspecialchars( $consulta['tabla'] );
          $campo = htmlspecialchars( $consulta['campo'] );
          $donde = htmlspecialchars( $consulta['donde'] );
          if( !empty( $tabla ) && !empty( $campo ) ) {
               if( empty( $donde ) ) {
                    $sql = "SELECT $campo FROM $tabla";
               } else {
                    $sql = "SELECT $campo FROM $tabla WHERE $donde";
               }
               $resultados = $this->conn->Execute( $sql );
               // Verificar resultados
               if( $this->conn->Affected_Rows( $resultados ) < 1 ) {
                    return false;
               } else {
                    return $resultados->fields[0];
               }
          } else {
               return false;
          }
     }
     // Ejecutar consulta personalizada
     public function ejecutar_consulta( $consulta ) {
          if( !empty( $consulta ) ) {
               $resultados = $this->conn->Execute( $consulta );
               if( $this->conn->Affected_Rows( $resultados ) < 1 ) {
                    return false;
               } else {
                    return true;
               }
          } else {
               return false;
          }
     }
}
?>

mi-extension-wordpress-opciones.php

<?php
/*
 * Fichero: mi-extension-wordpress-opciones.php
 * Página de opciones de tu extensión
 */
// Variables
@$licencia = htmlspecialchars( $_POST['licencia_miExtension'] );
// Guardar datos
if( !empty( $licencia ) ) {
     salvar_datos( $licencia, 'licencia_miExtension' );
     // Informar al usuario
     add_action( 'admin_notices', 'datos_guardados' );
}

// Capturar opciones
@$opciones = htmlspecialchars( $_GET['op'] );
if( !empty( $opciones ) ) {
     switch( $opciones ) {
          case 'borrar':
               borrar_datos( 'licencia_miExtension' );
               break;
     }
}

// Agregar al menú si es admin
if( is_admin() ) {
     add_action( 'admin_menu', 'crear_menu' );
}

// Función que crea el menú de opciones de nuestra extensión
function crear_menu() {
     // Crear menu de nivel superior
     add_menu_page( 'Opciones de Mi Extensión', 'Mi Extensión', 'administrator', __FILE__, mis_opciones );
     // Activar registro de opciones
     add_action( 'admin_init', 'registrar_opciones' );
}

// Opciones de la extensión
function mis_opciones() {
     // Preparar enlace para borrar la información almacenada
     if( get_option( 'licencia_miExtension' ) != false ) {
          $borrar_licencia = '<a href="?page=mi-extension-wordpress-opciones.php&op=borrar">Borrar Licencia</a>';
     }
     // Página de opciones
     $pag_op = '<div class="wrap">';
          $pag_op.= '<h2>Opciones de Mi Extensión</h2>';
          $pag_op.= '<hr />';
          $pag_op.= '<form method="post" action="#">';
               // Insertar opciones
               setting_fields( 'grupo-opciones' );
               do_settings_fields( __FILE__, 'grupo-opciones' );
               $pag_op.= '<table class="form-table">';
                    $pag_op.= '<tr valign="top">';
                         $pag_op.= '<th scope="row">Licencia de usuario</th>';
                         $pag_op.= '<td><input type="text" name="licencia_miExtension" value="'.get_option('licencia_miExtension').'" /> '.@$borrar_licencia.'</td>';
                    $pag_op.= '</tr>';
               $pag_op.= '</table>';
               $pag_op.= get_submit_button();
          $pag_op.= '</form>';
     $pag_op.= '</div>';
     // Mostrar formulario
     echo $pag_op;
}

// Registrar opciones
function registrar_opciones() {
     // Registrar opciones de nuestra extensión
     register_setting( 'grupo-opciones', 'licencia_miExtension', 'limpiar_datos' );
}

// Limpiar datos
function limpiar_datos( $datos ) {
     $datos = htmlspecialchars( $datos );
     return $datos;
}

// Salvar cambios
function salvar_datos( $opcion, $nombre_opcion ) {
     $opcion = htmlspecialchars( $opcion );
     $nombre_opcion = htmlspecialchars( $nombre_opcion );
     // Verificar si la opción no existe
     if( get_option( $nombre_opcion ) === false ) {
          // Crearla y guardar el valor introducido
          add_option( $nombre_opcion, $opcion );
     } elseif( get_option( $nombre_opcion ) != $opcion ) {
          // Actualizarla
          update_option( $nombre_opcion, $opcion );
     }
}

// Borrar datos guardados
function borrar_datos( $nombre_opcion ) {
     update_option( $nombre_opcion, "" );
     return;
}

// Notificar que los datos se guardaron
function datos_guardados() {
     // Página
     global $pagenow;
     if( $pagenow == 'admin.php' ) {
          echo '<div class="updated"><p>Licencia registrada correctamente.</p></div>';
     }
}

// Opciones por defecto para la activación
function opciones_base() {
     if( get_option( 'licencia_miExtension' ) === false ) {
          add_option( 'licencia_miExtension', '' );
     }
}
register_activation_hook( __FILE__, 'opciones_base' );

// Notificación de configuración
function configuracion_requerida() {
     // Página
     global $pagenow;
     // Mostrar en el panel principal, página de extensiones y de administración
     if( $pagenow == 'index.php' || $pagenow == 'plugins.php' || $pagenow == 'admin.php' ) {
          // Verificar que el usuario tiene permisos
          if( current_user_can( 'install_plugins' ) && current_user_can( 'manage_options' ) ) {
               $msj = '<div class="update">';
               $msj.= '<p>Por favor ingresa tu licencia para activar la extensión</p>';
               $msj.= '<p><a href="admin.php?page=mi-extension-wordpress-opciones.php">Ir a la página de opciones</a></p>';
               $msj.= '</div>';
               echo $msj;
          }
     }
}

// Notificación de actualización
function notifica_actualizacion() {
     // Página
     global $pagenow;
     if( $pagenow == 'index.php' || $pagenow == 'plugins.php' ) {
          if( current_user_can( 'install_plugins' ) && current_user_can( 'manage_options' ) ) {
               $msj = '<div class="update">';
               $msj.= '<p>Hay una nueva versión mayor, debes adquirir una nueva licencia.</p>';
               $msj.= '</div>';
               echo $msj;
          }
     }
}
?>

mi-extension-wordpress-p1.php

<?php
/**
 * Fichero: mi-extension-wordpress.php
 * Agrega esta variable para definir el número de versión
 */
define( 'MiExtension_Version', '1.0', true );
?>

mi-extension-wordpress-p2.php

<?php
/**
 * Fichero: mi-extension-wordpress.php
 * Función que verificará si existen nuevas versiones
 */
function buscar_actualizaciones() {
     // Número de versión
     $version_instalada = MiExtension_Version;
     // URL de nuestra API
     $url_api = 'http://api.miservidor.com/';
     // Slug (nombre sin espacios) de nuestra extensión
     $slug_extension = 'mi-extension-wordpress';
     // Ruta al fichero principal de nuestra extensión
     $fichero_principal = plugin_basename(__FILE__);
     // Licencia de usuario (registrada en la tabla opciones de WordPress)
     $licencia_usuario = get_option('licencia_miExtension');
     // Verificar que haya licencia y que sea valida
     if( !empty( $licencia_usuario ) && verificar_licencia( $url_api, $licencia_usuario ) === 'true' ) {
          // Consultar la API
          new api_actualizacion( $version_instalada, $url_api, $slug_extension, $fichero_principal, $licencia_usuario );
     } else {
          // Notificar al usuario que debe activar su copia
          add_action( 'admin_notices', 'notificar_configuracion' );
     }
}
?>

mi-extension-wordpress-p3.php

<?php
/**
 * Fichero: mi-extension-wordpress.php
 * Función que verificará la licencia de usuario
 */
function verificar_licencia( $url_api, $licencia ) {
     // Ejecutamos una consulta a nuestra API
     $consulta = wp_remote_post( $url_api, array( 'body' => array( 'que_consultar' => 'licencia', 'codigo' => $licencia, 'version' => MiExtension_Version ) ) );
     // Verificar respuesta
     if( !is_wp_error( $consulta ) || wp_remote_retrieve_response_code( $consulta ) === 200 ) {
          return $consulta['body'];
     }
     return false;
}
?>

mi-extension-wordpress.php

<?php
/**
 * Fichero: mi-extension-wordpress.php
 * Agrega esta variable para definir el número de versión
 */
define( 'MiExtension_Version', '1.0', true );
/**
 * Función que verificará si existen nuevas versiones
 */
function buscar_actualizaciones() {
     // Número de versión
     $version_instalada = MiExtension_Version;
     // URL de nuestra API
     $url_api = 'http://api.miservidor.com/';
     // Slug (nombre sin espacios) de nuestra extensión
     $slug_extension = 'mi-extension-wordpress';
     // Ruta al fichero principal de nuestra extensión
     $fichero_principal = plugin_basename(__FILE__);
     // Licencia de usuario (registrada en la tabla opciones de WordPress)
     $licencia_usuario = get_option('licencia_miExtension');
     // Verificar que haya licencia y que sea valida
     if( !empty( $licencia_usuario ) && verificar_licencia( $url_api, $licencia_usuario ) === 'true' ) {
          // Consultar la API
          new api_actualizacion( $version_instalada, $url_api, $slug_extension, $fichero_principal, $licencia_usuario );
     } else {
          // Notificar al usuario que debe activar su copia
          add_action( 'admin_notices', 'notificar_configuracion' );
     }
}
/**
 * Función que verificará la licencia de usuario
 */
function verificar_licencia( $url_api, $licencia ) {
     // Ejecutamos una consulta a nuestra API
     $consulta = wp_remote_post( $url_api, array( 'body' => array( 'que_consultar' => 'licencia', 'codigo' => $licencia, 'version' => MiExtension_Version ) ) );
     // Verificar respuesta
     if( !is_wp_error( $consulta ) || wp_remote_retrieve_response_code( $consulta ) === 200 ) {
          return $consulta['body'];
     }
     return false;
}
?>