Dave Jarvis' Repositories

RewriteEngine On

RewriteCond %{HTTP_USER_AGENT} SemrushBot [NC]

RewriteRule .* - [F]

RewriteRule ^(git|pages|render)/ - [F]

RewriteCond %{REQUEST_URI} !^/index\.php$

RewriteCond %{REQUEST_FILENAME} -f

RewriteRule \.php$ - [F]

RewriteCond %{REQUEST_FILENAME} !-f

RewriteRule ^(.*)$ index.php [QSA,L]

deny from 185.213.83.81

          $result = readfile( $path ) !== false;

        }

      }

    }

    return $result;

  }

  public function eachRef( callable $callback ): void {

    $head = $this->resolve( 'HEAD' );

    if( $head !== '' ) {

      $callback( 'HEAD', $head );

    }

    $this->refs->scanRefs( 'refs/heads', function( $n, $s ) use ( $callback ) {

      $callback( "refs/heads/$n", $s );

    } );

    $this->refs->scanRefs( 'refs/tags', function( $n, $s ) use ( $callback ) {

      $callback( "refs/tags/$n", $s );

    } );

  }

  public function generatePackfile( array $objs ): string {

    $pData = "PACK" . pack( 'N', 2 ) . pack( 'N', 0 );

    if( !empty( $objs ) ) {

      $data = '';

      foreach( $objs as $sha => $info ) {

        $cont  = $this->read( $sha );

        $size  = strlen( $cont );

        $byte  = $info['type'] << 4 | $size & 0x0f;

        $size >>= 4;

        while( $size > 0 ) {

          $data .= chr( $byte | 0x80 );

          $byte  = $size & 0x7f;

          $size >>= 7;

        }

        $data .= chr( $byte ) . gzcompress( $cont );

      }

      $pData = "PACK" . pack( 'N', 2 ) . pack( 'N', count( $objs ) ) . $data;

    }

    return $pData . hash( 'sha1', $pData, true );

  }

  private function getTreeSha( string $commitOrTreeSha ): string {

    $data = $this->read( $commitOrTreeSha );

    $sha  = $commitOrTreeSha;

    if( preg_match( '/^object ([0-9a-f]{40})/m', $data, $matches ) ) {

      $sha = $this->getTreeSha( $matches[1] );

    }

    if( $sha === $commitOrTreeSha &&

        preg_match( '/^tree ([0-9a-f]{40})/m', $data, $matches ) ) {

      $sha = $matches[1];

    }

    return $sha;

  }

  private function resolvePath( string $treeSha, string $path ): array {

    $parts = explode( '/', trim( $path, '/' ) );

    $sha   = $treeSha;

    $mode  = '40000';

    foreach( $parts as $part ) {

      $entry = [ 'sha' => '', 'mode' => '' ];

      if( $part !== '' && $sha !== '' ) {

        $entry = $this->findTreeEntry( $sha, $part );

      }

      $sha   = $entry['sha'];

      $mode  = $entry['mode'];

    }

    return [

      'sha'   => $sha,

      'mode'  => $mode,

      'isDir' => $mode === '40000' || $mode === '040000'

    ];

  }

  private function findTreeEntry( string $treeSha, string $name ): array {

    $data  = $this->read( $treeSha );

    $pos   = 0;

    $len   = strlen( $data );

    $entry = [ 'sha' => '', 'mode' => '' ];

    while( $pos < $len ) {

      $space = strpos( $data, ' ', $pos );

      $eos   = strpos( $data, "\0", $space );

      if( $space === false || $eos === false ) {

        break;

      }

      if( substr( $data, $space + 1, $eos - $space - 1 ) === $name ) {

        $entry = [

          'sha'  => bin2hex( substr( $data, $eos + 1, 20 ) ),

          'mode' => substr( $data, $pos, $space - $pos )

        ];

        break;

      }

      $pos = $eos + 21;

    }

    return $entry;

  }

  private function parseTagData(

    string $name,

    string $sha,

    string $data

  ): Tag {

    $isAnn   = strncmp( $data, 'object ', 7 ) === 0;

    $pattern = $isAnn

      ? '/^tagger (.*) <(.*)> (\d+) [+\-]\d{4}$/m'

      : '/^author (.*) <(.*)> (\d+) [+\-]\d{4}$/m';

    $id      = $this->parseIdentity( $data, $pattern );

    $target  = $isAnn

      ? $this->extractPattern( $data, '/^object (.*)$/m', 1, $sha )

      : $sha;

    return new Tag(

      $name,

      $sha,

      $target,

      $id['timestamp'],

      $this->extractMessage( $data ),

      $id['name']

    );

  }

  private function extractPattern(

    string $data,

    string $pattern,

    int $group,

    string $default = ''

  ): string {

    return preg_match( $pattern, $data, $matches )

      ? $matches[$group]

      : $default;

  }

  private function parseIdentity( string $data, string $pattern ): array {

    $found = preg_match( $pattern, $data, $matches );

    return [

      'name'      => $found ? trim( $matches[1] ) : 'Unknown',

      'email'     => $found ? $matches[2] : '',

      'timestamp' => $found ? (int)$matches[3] : 0

    ];

  }

  private function extractMessage( string $data ): string {

    $pos = strpos( $data, "\n\n" );

    return $pos !== false ? trim( substr( $data, $pos + 2 ) ) : '';

  }

  private function slurp( string $sha, callable $callback ): void {

    $path = $this->getLoosePath( $sha );

    if( is_file( $path ) ) {

      $this->slurpLooseObject( $path, $callback );

    } else {

      $this->slurpPackedObject( $sha, $callback );

    }

  }

  private function slurpLooseObject( string $path, callable $callback ): void {

    $this->iterateInflated(

      $path,

      function( $chunk ) use ( $callback ) {

        if( $chunk !== '' ) {

          $callback( $chunk );

        }

        return true;

      }

    );

  }

  private function slurpPackedObject( string $sha, callable $callback ): void {

    $streamed = $this->packs->stream( $sha, $callback );

    if( !$streamed ) {

      $data = $this->packs->read( $sha );

      if( $data !== '' ) {

        $callback( $data );

      }

    }

  }

  private function iterateInflated(

    string $path,

    callable $processor

  ): void {

    $handle = fopen( $path, 'rb' );

    $infl   = $handle ? inflate_init( ZLIB_ENCODING_DEFLATE ) : null;

    $found  = false;

    $buffer = '';

    if( $handle && $infl ) {

      while( !feof( $handle ) ) {

        $chunk    = fread( $handle, 16384 );

        $inflated = inflate_add( $infl, $chunk );

        if( $inflated === false ) {

          break;

        }

        if( !$found ) {

          $buffer .= $inflated;

          $eos     = strpos( $buffer, "\0" );

          if( $eos !== false ) {

            $found = true;

            $body  = substr( $buffer, $eos + 1 );

            $head  = substr( $buffer, 0, $eos );

            if( $processor( $body, $head ) === false ) {

              break;

            }

          }

        } elseif( $processor( $inflated, null ) === false ) {

          break;

        }

      }

      fclose( $handle );

    }

  }

  private function peekLooseObject( string $sha, int $length ): string {

    $path = $this->getLoosePath( $sha );

    $buf  = '';

    if( is_file( $path ) ) {

      $this->iterateInflated(

        $path,

        function( $chunk ) use ( $length, &$buf ) {

          $buf .= $chunk;

          return strlen( $buf ) < $length;

        }

      );

    }

    return substr( $buf, 0, $length );

  }

  private function parseCommit( string $sha ): object {

    $data   = $this->read( $sha );

    $result = (object)[ 'sha' => '' ];

    if( $data !== '' ) {

      $id = $this->parseIdentity(

        $data,

        '/^author (.*) <(.*)> (\d+)/m'

      );

      $result = (object)[

        'sha'       => $sha,

        'message'   => $this->extractMessage( $data ),

        'author'    => $id['name'],

        'email'     => $id['email'],

        'date'      => $id['timestamp'],

        'parentSha' => $this->extractPattern( $data, '/^parent (.*)$/m', 1 )

      ];

    }

    return $result;

  }

  private function walkTree( string $sha, callable $callback ): void {

    $data = $this->read( $sha );

    $tree = $data;

    if( $data !== '' && preg_match( '/^tree (.*)$/m', $data, $m ) ) {

      $tree = $this->read( $m[1] );

    }

    if( $tree !== '' && $this->isTreeData( $tree ) ) {

      $this->processTree( $tree, $callback );

    }

  }

  private function processTree( string $data, callable $callback ): void {

    $pos = 0;

    $len = strlen( $data );

    while( $pos < $len ) {

      $space = strpos( $data, ' ', $pos );

      $eos   = strpos( $data, "\0", $space );

      $entry = null;

      if( $space !== false && $eos !== false && $eos + 21 <= $len ) {

        $mode = substr( $data, $pos, $space - $pos );

        $sha  = bin2hex( substr( $data, $eos + 1, 20 ) );

        $isD  = $mode === '40000' || $mode === '040000';

        $entry = [

          'file' => new File(

            substr( $data, $space + 1, $eos - $space - 1 ),

            $sha,

            $mode,

            0,

            $isD ? 0 : $this->getObjectSize( $sha ),

            $isD ? '' : $this->peek( $sha )

          ),

          'nextPosition' => $eos + 21

        ];

      }

      if( $entry === null ) {

        break;

      }

      $callback( $entry['file'] );

      $pos = $entry['nextPosition'];

    }

  }

  private function isTreeData( string $data ): bool {

    $len   = strlen( $data );

    $patt  = '/^(40000|100644|100755|120000|160000) /';

    $match = $len >= 25 && preg_match( $patt, $data );

    $eos   = $match ? strpos( $data, "\0" ) : false;

    return $match && $eos !== false && $eos + 21 <= $len;

  }

  private function getLoosePath( string $sha ): string {

    return "{$this->objPath}/" . substr( $sha, 0, 2 ) . "/" .

      substr( $sha, 2 );

  }

  private function getLooseObjectSize( string $sha ): int {

    $path = $this->getLoosePath( $sha );

    $size = 0;

    if( is_file( $path ) ) {

      $this->iterateInflated(

        $path,

        function( $c, $head ) use ( &$size ) {

          if( $head !== null ) {

            $parts = explode( ' ', $head );

            $size  = isset( $parts[1] ) ? (int)$parts[1] : 0;

          }

          return false;

        }

      );

    }

    return $size;

  }

  public function collectObjects( array $wants, array $haves = [] ): array {

    $objs   = [];

    $result = [];

    foreach( $wants as $sha ) {

      $objs = $this->collectObjectsRecursive( $sha, $objs, 0 );

    }

    foreach( $haves as $sha ) {

      if( isset( $objs[$sha] ) ) {

        unset( $objs[$sha] );

      }

    }

    $result = $objs;

    return $result;

  }

  private function collectObjectsRecursive(

    string $sha,

    array $objs,

    int $expectedType = 0

  ): array {

    $result = $objs;

    if( !isset( $result[$sha] ) ) {

      $data = $this->read( $sha );

      $type = $expectedType === 0

        ? $this->getObjectType( $data )

        : $expectedType;

      $result[$sha] = [

        'type' => $type,

        'size' => strlen( $data )

      ];

      if( $type === 1 ) {

        $hasTree = preg_match( '/^tree ([0-9a-f]{40})/m', $data, $m );

        if( $hasTree ) {

          $result = $this->collectObjectsRecursive( $m[1], $result, 2 );

        }

        $hasParents = preg_match_all(

          '/^parent ([0-9a-f]{40})/m',

          $data,

          $m

        );

        if( $hasParents ) {

          foreach( $m[1] as $parentSha ) {

            $result = $this->collectObjectsRecursive(

              $parentSha,

              $result,

              1

            );

          }

        }

      }

      if( $type === 2 ) {

        $pos = 0;

        $len = strlen( $data );

        while( $pos < $len ) {

          $sp  = strpos( $data, ' ', $pos );

          $eos = strpos( $data, "\0", $sp );

          if( $sp === false || $eos === false ) {

            break;

          }

          $mode     = substr( $data, $pos, $sp - $pos );

          $s        = bin2hex( substr( $data, $eos + 1, 20 ) );

          $isDir    = $mode === '40000' || $mode === '040000';

          $nextType = $isDir ? 2 : 3;

          $pos      = $eos + 21;

          $result = $this->collectObjectsRecursive(

            $s,

            $result,

            $nextType

          );

        }

      }

      $isTagTarget = $type === 4 &&

        preg_match( '/^object ([0-9a-f]{40})/m', $data, $m );

      if( $isTagTarget ) {

        $nextType = 1;

        if( preg_match( '/^type (commit|tree|blob|tag)/m', $data, $t ) ) {

          $map = [

            'commit' => 1,

            'tree'   => 2,

            'blob'   => 3,

            'tag'    => 4

          ];

          $nextType = $map[$t[1]] ?? 1;

        }

        $result = $this->collectObjectsRecursive(

          $m[1],

          $result,

          $nextType

        );

      }

    }

    return $result;

  private const MAX_BASE_RAM = 524288;

  private const MAX_DEPTH    = 50;

  private string $objectsPath;

  private array  $packFiles;

  private string $lastPack = '';

  private array  $fileHandles;

  private array  $fanoutCache;

  private array  $shaBucketCache;

  private array  $offsetBucketCache;

  public function __construct( string $objectsPath ) {

    $this->objectsPath       = $objectsPath;

    $this->packFiles         = glob( "{$this->objectsPath}/pack/*.idx" ) ?: [];

    $this->fileHandles       = [];

    $this->fanoutCache       = [];

    $this->shaBucketCache    = [];

    $this->offsetBucketCache = [];

  }

  public function __destruct() {

    foreach( $this->fileHandles as $handle ) {

      if( is_resource( $handle ) ) {

        fclose( $handle );

      }

    }

  }

  public function peek( string $sha, int $len = 12 ): string {

    $info   = $this->findPackInfo( $sha );

    $result = '';

    if( $info['offset'] !== 0 ) {

      $handle = $this->getHandle( $info['file'] );

      if( $handle ) {

        $result = $this->readPackEntry(

          $handle,

          $info['offset'],

          $len,

          $len

        );

      }

    }

    return $result;

  }

  public function read( string $sha ): string {

    $info   = $this->findPackInfo( $sha );

    $result = '';

    if( $info['offset'] !== 0 ) {

      $size = $this->extractPackedSize( $info['file'], $info['offset'] );

      if( $size <= self::MAX_RAM ) {

        $handle = $this->getHandle( $info['file'] );

        if( $handle ) {

          $result = $this->readPackEntry(

            $handle,

            $info['offset'],

            $size

          );

        }

      }

    }

    return $result;

  }

  public function stream( string $sha, callable $callback ): bool {

    return $this->streamInternal( $sha, $callback, 0 );

  }

  private function streamInternal(

    string $sha,

    callable $callback,

    int $depth

  ): bool {

    $info   = $this->findPackInfo( $sha );

    $result = false;

    if( $info['offset'] !== 0 ) {

      $size   = $this->extractPackedSize( $info['file'], $info['offset'] );

      $handle = $this->getHandle( $info['file'] );

      if( $handle ) {

        $result = $this->streamPackEntry(

          $handle,

          $info['offset'],

          $size,

          $callback,

          $depth

        );

      }

    }

    return $result;

  }

  public function getSize( string $sha ): int {

    $info   = $this->findPackInfo( $sha );

    $result = 0;

    if( $info['offset'] !== 0 ) {

      $result = $this->extractPackedSize( $info['file'], $info['offset'] );

    }

    return $result;

  }

  private function findPackInfo( string $sha ): array {

    $result = [ 'offset' => 0, 'file' => '' ];

    if( strlen( $sha ) === 40 && ctype_xdigit( $sha ) ) {

      $binarySha = hex2bin( $sha );

      if( $this->lastPack !== '' ) {

        $offset = $this->findInIdx( $this->lastPack, $binarySha );

        if( $offset !== 0 ) {

          $result = [

            'file'   => str_replace( '.idx', '.pack', $this->lastPack ),

            'offset' => $offset

          ];

        }

      }

      if( $result['offset'] === 0 ) {

        foreach( $this->packFiles as $indexFile ) {

          if( $indexFile !== $this->lastPack ) {

            $offset = $this->findInIdx( $indexFile, $binarySha );

            if( $offset !== 0 ) {

              $this->lastPack = $indexFile;

              $result         = [

                'file'   => str_replace( '.idx', '.pack', $indexFile ),

                'offset' => $offset

              ];

              break;

            }

          }

        }

      }

    }

    return $result;

  }

  private function findInIdx( string $indexFile, string $binarySha ): int {

    $handle = $this->getHandle( $indexFile );

    $result = 0;

    if( $handle ) {

      if( !isset( $this->fanoutCache[$indexFile] ) ) {

        fseek( $handle, 0 );

        $head = fread( $handle, 8 );

        if( $head === "\377tOc\0\0\0\2" ) {

          $this->fanoutCache[$indexFile] = array_values(

            unpack( 'N*', fread( $handle, 1024 ) )

          );

        }

      }

      if( isset( $this->fanoutCache[$indexFile] ) ) {

        $fanout = $this->fanoutCache[$indexFile];

        $byte   = ord( $binarySha[0] );

        $start  = $byte === 0 ? 0 : $fanout[$byte - 1];

        $end    = $fanout[$byte];

        if( $end > $start ) {

          $result = $this->binarySearchIdx(

            $indexFile,

            $handle,

            $start,

            $end,

            $binarySha,

            $fanout[255]

          );

        }

      }

    }

    return $result;

  }

  private function binarySearchIdx(

    string $indexFile,

    $handle,

    int $start,

    int $end,

    string $binarySha,

    int $total

  ): int {

    $key    = "$indexFile:$start";

    $count  = $end - $start;

    $result = 0;

    if( !isset( $this->shaBucketCache[$key] ) ) {

      fseek( $handle, 1032 + ($start * 20) );

      $this->shaBucketCache[$key] = fread( $handle, $count * 20 );

      fseek( $handle, 1032 + ($total * 24) + ($start * 4) );

      $this->offsetBucketCache[$key] = fread( $handle, $count * 4 );

    }

    $shaBlock = $this->shaBucketCache[$key];

    $low      = 0;

    $high     = $count - 1;

    $found    = -1;

    while( $low <= $high ) {

      $mid = ($low + $high) >> 1;

      $cmp = substr( $shaBlock, $mid * 20, 20 );

      if( $cmp < $binarySha ) {

        $low = $mid + 1;

      } elseif( $cmp > $binarySha ) {

        $high = $mid - 1;

      } else {

        $found = $mid;

        break;

      }

    }

    if( $found !== -1 ) {

      $packed = substr( $this->offsetBucketCache[$key], $found * 4, 4 );

      $offset = unpack( 'N', $packed )[1];

      if( $offset & 0x80000000 ) {

        $pos64 = 1032 + ($total * 28) + (($offset & 0x7FFFFFFF) * 8);

        fseek( $handle, $pos64 );

        $offset = unpack( 'J', fread( $handle, 8 ) )[1];

      }

      $result = (int)$offset;

    }

    return $result;

  }

  private function readPackEntry(

    $handle,

    int $offset,

    int $size,

    int $cap = 0

  ): string {

    fseek( $handle, $offset );

    $header = $this->readVarInt( $handle );

    $type   = ($header['byte'] >> 4) & 7;

    return ($type === 6)

      ? $this->handleOfsDelta( $handle, $offset, $size, $cap )

      : (($type === 7)

        ? $this->handleRefDelta( $handle, $size, $cap )

        : $this->decompressToString( $handle, $cap ));

  }

  private function streamPackEntry(

    $handle,

    int $offset,

    int $size,

    callable $callback,

    int $depth = 0

  ): bool {

    fseek( $handle, $offset );

    $header = $this->readVarInt( $handle );

    $type   = ($header['byte'] >> 4) & 7;

    return ($type === 6 || $type === 7)

      ? $this->streamDeltaObject( $handle, $offset, $type, $callback, $depth )

      : $this->streamDecompression( $handle, $callback );

  }

  private function streamDeltaObject(

    $handle,

    int $offset,

    int $type,

    callable $callback,

    int $depth = 0

  ): bool {

    if( $depth >= self::MAX_DEPTH ) {

      return false;

    }

    fseek( $handle, $offset );

    $this->readVarInt( $handle );

    $result = false;

    if( $type === 6 ) {

      $neg      = $this->readOffsetDelta( $handle );

      $deltaPos = ftell( $handle );

      $base     = '';

      $baseSize = $this->extractPackedSize( $handle, $offset - $neg );

      if( $baseSize > self::MAX_BASE_RAM ) {

        return false;

      }

      $this->streamPackEntry(

        $handle,

        $offset - $neg,

        0,

        function( $c ) use ( &$base ) { $base .= $c; },

        $depth + 1

      );

      fseek( $handle, $deltaPos );

      $result = $this->applyDeltaStream( $handle, $base, $callback );

    } else {

      $baseSha  = bin2hex( fread( $handle, 20 ) );

      $baseSize = $this->getSize( $baseSha );

      if( $baseSize > self::MAX_BASE_RAM ) {

        return false;

      }

      $base = '';

      if( $this->streamInternal( $baseSha, function( $c ) use ( &$base ) {

        $base .= $c;

      }, $depth + 1 ) ) {

        $result = $this->applyDeltaStream( $handle, $base, $callback );

      }

    }

    return $result;

  }

  private function applyDeltaStream(

    $handle,

    string $base,

    callable $callback

  ): bool {

    $infl = inflate_init( ZLIB_ENCODING_DEFLATE );

    $ok   = false;

    if( $infl ) {

      $state  = 0;

      $buffer = '';

      $ok     = true;

      while( !feof( $handle ) ) {

        $chunk = fread( $handle, 8192 );

        if( $chunk === '' ) {

          break;

        }

        $data = @inflate_add( $infl, $chunk );

        if( $data === false ) {

          $ok = false;

          break;

        }

        $buffer .= $data;

        while( true ) {

          $len = strlen( $buffer );

          if( $len === 0 ) {

            break;

          }

          if( $state < 2 ) {

            $pos = 0;

            while( $pos < $len && (ord( $buffer[$pos] ) & 128) ) { $pos++; }

            if( $pos === $len && (ord( $buffer[$pos - 1] ) & 128) ) {

              break;

            }

            $buffer = substr( $buffer, $pos + 1 );

            $state++;

            continue;

          }

          $op = ord( $buffer[0] );

          if( $op & 128 ) {

            $need = $this->getCopyInstructionSize( $op );

            if( $len < 1 + $need ) {

              break;

            }

            $info = $this->parseCopyInstruction( $op, $buffer, 1 );

            $callback( substr( $base, $info['off'], $info['len'] ) );

            $buffer = substr( $buffer, 1 + $need );

          } else {

            $ln = $op & 127;

            if( $len < 1 + $ln ) {