<?php
$directorio = opendir("/ruta/de_los_archivos/"); 
while ($archivo = readdir($directorio)) //obtenemos un archivo y luego otro sucesivamente
{
    if (is_dir($archivo))//verificamos si es o no un directorio
    {
        //Si es un directorio no hacemos nada
    }
    else
    {
        echo "<a href='" . $directorio . $archivo . "'>" . $directorio . $archivo . </a>";
    }
}
?>

#!/usr/bin/perl

use strict;

my $respuesta = qx("curl -v http://url");

while($respuesta ne "cadena de salida certera"){

     system("comando que levanta el server");
     my $respuesta = qx("curl -v http://url");
}

exit;

	namespace Practicando_dotNet
	{
		class Program
		{
			static void Main()
			{
				System.Console.WriteLine("Hola mundo");
				System.Console.ReadKey();
			}
		}
	}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using Utilities;
 
namespace key_preview {
        public partial class Form1 : Form {
                globalKeyboardHook gkh = new globalKeyboardHook();
 
        MouseMover MM = new MouseMover();
 
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern void mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);
 
        private const int MOUSEEVENTF_LEFTDOWN = 0x02;
        private const int MOUSEEVENTF_LEFTUP = 0x04;
        private const int MOUSEEVENTF_RIGHTDOWN = 0x08;
        private const int MOUSEEVENTF_RIGHTUP = 0x10;
 
                public Form1() {
                        InitializeComponent();
                }
 
        bool flag = true;
 
                private void Form1_Load(object sender, EventArgs e) {
                       
            gkh.HookedKeys.Add(Keys.W);
            gkh.HookedKeys.Add(Keys.A);
            gkh.HookedKeys.Add(Keys.S);
            gkh.HookedKeys.Add(Keys.D);
            gkh.HookedKeys.Add(Keys.Q);
            gkh.HookedKeys.Add(Keys.E);
            gkh.HookedKeys.Add(Keys.R);
            gkh.HookedKeys.Add(Keys.F);
            gkh.HookedKeys.Add(Keys.D);
            gkh.HookedKeys.Add(Keys.P);
 
 
                        gkh.KeyDown += new KeyEventHandler(gkh_KeyDown);
               
 
                }
 
 
 
                void gkh_KeyDown(object sender, KeyEventArgs e) {
 
            if (flag == true)
            {
                switch (e.KeyCode)
                {
                    case Keys.W:
                        MM.arriba();
                        break;
 
                    case Keys.S:
                        MM.abajo();
                        break;
 
                    case Keys.A:
                        MM.izquierda();
                        break;
 
                    case Keys.D:
                        MM.derecha();
                        break;
 
                    case Keys.F:
                        MM.bajarsens();
                        break;
 
                    case Keys.R:
                        MM.subirsens();
                        break;
 
                    case Keys.Q:
                        mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, Cursor.Position.X, Cursor.Position.Y, 0, 0);
 
                        break;
 
                    case Keys.E:
                        mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, Cursor.Position.X, Cursor.Position.Y, 0, 0);
 
                        break;
                }
            }
 
            if (e.KeyCode == Keys.P)
            {
                if (flag == true)
                {
                    flag = false;
                }
                else
                {
                    flag = true;
                }
 
            }
           
                        e.Handled = true;
                }
 
   
        }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
 
namespace Utilities {
        /// <summary>
        /// A class that manages a global low level keyboard hook
        /// </summary>
        class globalKeyboardHook {
                #region Constant, Structure and Delegate Definitions
                /// <summary>
                /// defines the callback type for the hook
                /// </summary>
                public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);
 
                public struct keyboardHookStruct {
                        public int vkCode;
                        public int scanCode;
                        public int flags;
                        public int time;
                        public int dwExtraInfo;
                }
 
                const int WH_KEYBOARD_LL = 13;
                const int WM_KEYDOWN = 0x100;          
                const int WM_SYSKEYDOWN = 0x104;
                #endregion
 
                #region Instance Variables
                /// <summary>
                /// The collections of keys to watch for
                /// </summary>
                public List<Keys> HookedKeys = new List<Keys>();
                /// <summary>
                /// Handle to the hook, need this to unhook and call the next hook
                /// </summary>
                IntPtr hhook = IntPtr.Zero;
                #endregion
 
                #region Events
                /// <summary>
                /// Occurs when one of the hooked keys is pressed
                /// </summary>
                public event KeyEventHandler KeyDown;
                /// <summary>
                /// Occurs when one of the hooked keys is released
                /// </summary>
       
                #endregion
 
                #region Constructors and Destructors
                /// <summary>
                /// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
                /// </summary>
                public globalKeyboardHook() {
                        hook();
                }
 
                /// <summary>
                /// Releases unmanaged resources and performs other cleanup operations before the
                /// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
                /// </summary>
                ~globalKeyboardHook() {
                        unhook();
                }
                #endregion
 
                #region Public Methods
                /// <summary>
                /// Installs the global hook
                /// </summary>
                public void hook() {
                        IntPtr hInstance = LoadLibrary("User32");
                        hhook = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0);
                }
 
                /// <summary>
                /// Uninstalls the global hook
                /// </summary>
                public void unhook() {
                        UnhookWindowsHookEx(hhook);
                }
 
                /// <summary>
                /// The callback for the keyboard hook
                /// </summary>
                /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
                /// <param name="wParam">The event type</param>
                /// <param name="lParam">The keyhook event information</param>
                /// <returns></returns>
                public int hookProc(int code, int wParam, ref keyboardHookStruct lParam) {
                        if (code >= 0) {
                                Keys key = (Keys)lParam.vkCode;
                                if (HookedKeys.Contains(key)) {
                                        KeyEventArgs kea = new KeyEventArgs(key);
                                        if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null)) {
                                                KeyDown(this, kea) ;
                                        }
                                        if (kea.Handled)
                                                return 1;
                                }
                        }
                        return CallNextHookEx(hhook, code, wParam, ref lParam);
                }
                #endregion
 
                #region DLL imports
                /// <summary>
                /// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
                /// </summary>
                /// <param name="idHook">The id of the event you want to hook</param>
                /// <param name="callback">The callback.</param>
                /// <param name="hInstance">The handle you want to attach the event to, can be null</param>
                /// <param name="threadId">The thread you want to attach the event to, can be null</param>
                /// <returns>a handle to the desired hook</returns>
                [DllImport("user32.dll")]
                static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);
 
                /// <summary>
                /// Unhooks the windows hook.
                /// </summary>
                /// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
                /// <returns>True if successful, false otherwise</returns>
                [DllImport("user32.dll")]
                static extern bool UnhookWindowsHookEx(IntPtr hInstance);
 
                /// <summary>
                /// Calls the next hook.
                /// </summary>
                /// <param name="idHook">The hook id</param>
                /// <param name="nCode">The hook code</param>
                /// <param name="wParam">The wparam.</param>
                /// <param name="lParam">The lparam.</param>
                /// <returns></returns>
                [DllImport("user32.dll")]
                static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);
 
                /// <summary>
                /// Loads the library.
                /// </summary>
                /// <param name="lpFileName">Name of the library</param>
                /// <returns>A handle to the library</returns>
                [DllImport("kernel32.dll")]
                static extern IntPtr LoadLibrary(string lpFileName);
                #endregion
        }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
 
 
namespace Utilities
{
    class MouseMover
    {
        private int sens;
 
        public MouseMover()
        {
            this.sens = 20;
        }
 
        public void derecha()
        {
            Cursor.Position = new Point(Cursor.Position.X + sens, Cursor.Position.Y);    
        }
 
        public void izquierda()
        {
            Cursor.Position = new Point(Cursor.Position.X - sens, Cursor.Position.Y);
        }
 
        public void arriba()
        {
            Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y - sens);
        }
 
        public void abajo()
        {
            Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y + sens);
        }
 
        public void subirsens()
        {
           
         if (this.sens < 300)
            {
                this.sens = sens + 40;
            }
        }
 
        public void bajarsens()
        {
 
            if (this.sens == 20)
            {
                this.sens = 10;
            }
            else
            {
                this.sens = 20;
            }
           
        }
 
    }
}
 
}

namespace key_preview {
        partial class Form1 {
                /// <summary>
                /// Required designer variable.
                /// </summary>
                private System.ComponentModel.IContainer components = null;
 
                /// <summary>
                /// Clean up any resources being used.
                /// </summary>
                /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
                protected override void Dispose(bool disposing) {
                        if (disposing && (components != null)) {
                                components.Dispose();
                        }
                        base.Dispose(disposing);
                }
 
                #region Windows Form Designer generated code
 
                /// <summary>
                /// Required method for Designer support - do not modify
                /// the contents of this method with the code editor.
                /// </summary>
                private void InitializeComponent() {
            this.SuspendLayout();
            //
            // Form1
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            ths.ClientSize = new System.Drawing.Size(292, 266);
            this.KeyPreview = true;
            this.Name = "Form1";
            this.Text = "Form1";
            this.Load += new System.EventHandler(this.Form1_Load);
            this.ResumeLayout(false);
 
                }
 
                #endregion
 
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <string.h>
#include <errno.h>
 
void Direc();
void FileSize(char  fileN[200]);
void Cifrar(char fileN[200]);
 
int main(){
 
        Direc();
        return 0;
}
 
void Cifrar(char fileN[200]){
 

        char c;
        int clave;
 
        clave = rand()% 255 + 0;


        FILE *file;
        file = fopen(fileN, "rb+");
 
        int i = 0;
        while((c = fgetc(file)) != EOF){
                fseek(file, i, SEEK_SET);
                i++;
                fputc((c ^ clave), file);
        }
        i = 0;
        fclose(file);
        printf("   Crifrado. \n");

}
 
void Direc(){

        char ndir[200];
        char *p=getenv("USER");
 
        printf(" [>>] Introduca el directorio: \n");
        printf("  %s~$: ",p);
        scanf("%s", ndir);

        printf("%s\n",ndir);
 
        DIR *dir;
        struct dirent *ent; 
        dir = opendir(ndir);
 
        if(dir == NULL){
                printf("  [>>] Error al buscar el directorio \n");
        }
 
        while((ent = readdir(dir)) != NULL){
                if((strcmp(ent->d_name, ".") != 0) && (strcmp(ent->d_name, "..") !=0) ){

                        printf("%s", ent->d_name);
                        strcat(ndir,ent->d_name);       
                        FileSize(ndir);
               }

        }
}
 
void FileSize(char fileN[200]){
 
        long ftam = -1;
        FILE *file;
        file = fopen("fileN", "r");
 
        if(file){
                fseek(file, 0L, SEEK_END);
                ftam = ftell(file);
                fclose(file);
                printf("%30s (%ld bytes)",fileN, ftam);
        }else{
                printf("no file \n");
        }
        Cifrar(fileN);
}