1 # Copyright (c) 2000-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 # All rights reserved.

     3 # This component and the accompanying materials are made available

     4 # under the terms of the License "Eclipse Public License v1.0"

     5 # which accompanies this distribution, and is available

     6 # at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 # 

     8 # Initial Contributors:

     9 # Nokia Corporation - initial contribution.

    10 # 

    11 # Contributors:

    12 # 

    13 # Description:

    14 # 

    15 #

    16 

    17 package IniData;

    18 

    19 use strict;

    20 use FindBin;

    21 use File::Path;

    22 use File::Spec;

    23 use Utils;

    24 use PathData;

    25 

    26 our $cache = {}; # Persistent (private) cache

    27 

    28 $|++;

    29 

    30 #

    31 # Constants.

    32 #

    33 

    34 my $iniName = \ 'reltools.ini';

    35 my $envDir = undef; # only filled in when we do New()

    36 my $binDir = \ "$FindBin::Bin\\";

    37 my @standardIgnores = ('\\epoc32\\build\\*',

    38            '\\epoc32\\wins\\c\\*',

    39            '\\epoc32\\winscw\\c\\*',

    40            '\\epoc32\\release\\*.ilk',

    41            '\\epoc32\\release\\*.bsc',

    42            '\\epoc32\\data\\emulator\\*.sys.ini',

    43            '\\epoc32\\release\\tools\\*',

    44            '\\epoc32\\release\\tools2\\*'

    45           );

    46 

    47 # Support for target alias file

    48 use constant CBR_TARGET_ALIAS_LOCATION => scalar "\\epoc32\\tools\\variant\\";

    49 

    50 #

    51 # Constructor

    52 #

    53 

    54 sub New {

    55   my $pkg = shift;  

    56   my $filename = shift;

    57   my $ignoreepocroot = shift;

    58 

    59   if ( defined ($ENV{EPOCROOT}) or ! $ignoreepocroot ){

    60      $envDir = \ Utils::PrependEpocRoot("\\epoc32\\relinfo\\");

    61   }

    62   

    63   my $self = {};

    64   

    65   $self->{warnIniLocation} = 0;

    66   # Support for target alias file

    67   # This is a persistant flag.

    68   # If set then a warning must be printed if either HasTargetPlatforms()

    69   # or TargetPlatforms() is used. The flag is then cleared thus the warning is a one off.

    70   # If clear this is because the cbrtargetsalias.cfg file has been found

    71   # or the no_target_alias_warning flag is set in reltools.ini

    72   $self->{mustWarnTargetAliasLocation} = 1;

    73   if (defined $filename and -e $filename ) {

    74     $self->{iniFileName} = $filename;

    75   } elsif (defined $$envDir and -e "$$envDir$$iniName" ) {

    76     $self->{iniFileName} = "$$envDir$$iniName";

    77   } elsif (-e "$$binDir$$iniName") {

    78     $self->{warnIniLocation} = 1;

    79     $self->{iniFileName} = "$$binDir$$iniName";

    80   } else {

    81     my $msg = "Error: \"$$iniName\" not found in ";

    82     $msg = $msg."either \"$$envDir\" or " if ( defined ($$envDir));

    83     $msg = $msg."\"$$binDir\"\n";

    84     die $msg;

    85   }

    86 

    87   if ($cache->{lc($self->{iniFileName})}) {           

    88     return $cache->{lc($self->{iniFileName})};

    89   }

    90 

    91   foreach my $thisIgnore (@standardIgnores) {

    92     push (@{$self->{binIgnore}}, $thisIgnore);

    93   }

    94 

    95   bless $self, $pkg; # $self isn't blessed until we know we need it

    96 

    97   $self->ReadIni();

    98 

    99   # Support for target alias file

   100   if (!$ignoreepocroot) {

   101     $self->{targetAliasName} = Utils::PrependEpocRoot(CBR_TARGET_ALIAS_LOCATION).'cbrtargetalias.cfg';

   102 

   103     if ($self->ReadTargetAliasFile == 1) {

   104       # Successful read so clear the warning flag

   105       $self->{mustWarnTargetAliasLocation} = 0;

   106     }

   107   }

   108 

   109   $cache->{lc($self->{iniFileName})} = $self;

   110 

   111   return $self;

   112 }

   113 

   114 #

   115 # Public

   116 #

   117 

   118 sub DiffTool {

   119   my $self = shift;

   120   unless (exists $self->{diff_tool}) {

   121     return undef;

   122   }

   123   return $self->{diff_tool};

   124 }

   125 

   126 sub RequireInternalVersions {

   127   my $self = shift;

   128   if (exists $self->{require_internal_versions}) {

   129     return 1;

   130   }

   131   return 0;

   132 }

   133 

   134 sub IgnoreSourceFilterErrors {

   135   my $self = shift;

   136   if (exists $self->{ignore_source_filter_errors}) {

   137     return 1;

   138   }

   139   return 0;

   140 }

   141 

   142 sub RemoteSiteType {

   143   my $self = shift;

   144 

   145   unless (exists $self->{remote_site_type}) {

   146     $self->{remote_site_type} = 'FTP';

   147   }

   148   elsif ($self->{remote_site_type} =~ /(network|drive)/i) {

   149     $self->{remote_site_type} = 'NetDrive';

   150   }

   151   elsif ($self->{remote_site_type} =~ /experimentalproxy/i) {

   152     $self->{remote_site_type} = 'FTP::Proxy::Experimental';

   153   }

   154   elsif ($self->{remote_site_type} =~ /experimentalftp/i) {

   155     $self->{remote_site_type} = 'FTP::Experimental';

   156   }

   157   elsif ($self->{remote_site_type} =~ /multivolumeexport/i) {

   158     $self->{remote_site_type} = 'NetDrive::MultiVolumeExport';

   159   }

   160   elsif ($self->{remote_site_type} =~ /multivolumeimport/i) {

   161     $self->{remote_site_type} = 'NetDrive::MultiVolumeImport';

   162   }

   163   elsif ($self->{remote_site_type} =~ /proxy/i) {

   164     $self->{remote_site_type} = 'FTP::Proxy';

   165   }  

   166   else {

   167     $self->{remote_site_type} = 'FTP';

   168   }

   169   return $self->{remote_site_type};

   170 }

   171 

   172 sub RemoteHost {

   173   my $self = shift;

   174   unless (exists $self->{remote_host}) {

   175     return undef;

   176   }

   177   return $self->{remote_host};

   178 }

   179 

   180 sub RemoteUsername {

   181   my $self = shift;

   182   unless (exists $self->{remote_username}) {

   183     return undef;

   184   }

   185   return $self->{remote_username};

   186 }

   187 

   188 sub RemotePassword {

   189   my $self = shift;

   190   unless (exists $self->{remote_password}) {

   191     return undef;

   192   }

   193   return $self->{remote_password};

   194 }

   195 

   196 sub RemoteLogsDir {

   197   my $self = shift;

   198   unless (exists $self->{remote_logs}) {

   199     return undef;

   200   }

   201   return $self->{remote_logs};

   202 }

   203 

   204 sub Proxy {

   205   my $self = shift;

   206   unless (exists $self->{proxy}) {

   207     return undef;

   208   }

   209   return $self->{proxy};

   210 }

   211 

   212 sub ProxyUsername {

   213   my $self = shift;

   214   unless (exists $self->{proxy_username}) {

   215     return undef;

   216   }

   217   return $self->{proxy_username};

   218 }

   219 

   220 sub ProxyPassword {

   221   my $self = shift;

   222   unless (exists $self->{proxy_password}) {

   223     return undef;

   224   }

   225   return $self->{proxy_password};

   226 }

   227 

   228 sub PasvTransferMode {

   229   my $self = shift;

   230   if (exists $self->{pasv_transfer_mode}) {

   231     return 1;

   232   }

   233   return 0;

   234 }

   235 

   236 sub FtpServerSupportsResume {

   237   my $self = shift;

   238   if (defined $_[0]) {

   239     $self->{ftp_server_supports_resume} = $_[0];

   240   }

   241   if (exists $self->{ftp_server_supports_resume}) {

   242     return $self->{ftp_server_supports_resume} ? 1 : 0;

   243   }

   244   return 0;

   245 }

   246 

   247 sub FtpTimeout {

   248   my $self = shift;

   249   unless (exists $self->{ftp_timeout}) {

   250     return undef;

   251   }

   252   return $self->{ftp_timeout};

   253 }

   254 

   255 sub FtpReconnectAttempts {

   256   my $self = shift;

   257   unless (exists $self->{ftp_reconnect_attempts}) {

   258     return undef;

   259   }

   260   return $self->{ftp_reconnect_attempts};

   261 }

   262 

   263 sub TempDir {

   264   my $self = shift;

   265   if (exists $self->{temp_dir}) {

   266     return $self->{temp_dir};

   267   }

   268   return undef;

   269 }

   270 

   271 sub MaxExportVolumeSize {

   272   my $self = shift;

   273   if (exists $self->{max_export_volume_size}) {

   274     return $self->{max_export_volume_size};

   275   }

   276   else {

   277     return 639 * 1024 * 1024;

   278   }

   279 }

   280 

   281 sub PgpTool {

   282   my $self = shift;

   283 

   284   unless (exists $self->{pgp_tool}) {

   285     $self->{pgp_tool} = 'PGP';

   286   }

   287   elsif ($self->{pgp_tool} =~ /(gpg|gnupg)/i) {

   288     $self->{pgp_tool} = 'GPG';

   289   }

   290   else {

   291     $self->{pgp_tool} = 'PGP';

   292   }

   293   return $self->{pgp_tool};

   294 }

   295 

   296 sub PgpEncryptionKeys {

   297   my $self = shift;

   298   unless (exists $self->{pgp_encryption_keys}) {

   299     return [];

   300   }

   301   return $self->{pgp_encryption_keys};

   302 }

   303 

   304 sub PgpConfigPath {

   305   my $self = shift;

   306   unless (exists $self->{pgp_config_path}) {

   307     return undef;

   308   }

   309   return $self->{pgp_config_path};

   310 }

   311 

   312 sub ExportDataFile {

   313   my $self = shift;

   314   unless (exists $self->{export_data_file}) {

   315     die "Error: export_data_file keyword not specified in reltools.ini\n";

   316   }

   317   return $self->{export_data_file};

   318 }

   319 

   320 sub PathData {

   321   my $self = shift;

   322   unless (defined $self->{pathData}) {

   323     $self->{pathData} = PathData->New($self->{verbose});

   324   }

   325   return $self->{pathData};

   326 }

   327 

   328 sub HtmlNotes {

   329   my $self = shift;

   330   return (exists $self->{html_notes});

   331 }

   332 

   333 sub FromMapping {

   334   my $self = shift;

   335   my @fromMapping;

   336 

   337   if(defined @{$self->{from_mapping}}){

   338     @fromMapping = @{$self->{from_mapping}};

   339   }

   340 

   341   return @fromMapping;

   342 }

   343 

   344 sub ToMapping {

   345   my $self = shift;

   346   my @toMapping;

   347 

   348   if(defined @{$self->{to_mapping}}){

   349     @toMapping = @{$self->{to_mapping}};

   350   }

   351 

   352   return @toMapping;

   353 }

   354 

   355 sub HasMappings {

   356   my $self = shift;

   357   my $result = 0;

   358 

   359   if(defined @{$self->{from_mapping}} && defined @{$self->{to_mapping}} && Utils::SourceRoot() eq "\\"){

   360     $result = 1;

   361   }

   362 

   363   return $result;

   364 }

   365 

   366 sub PerformMapOnFileName {

   367   my $self = shift;

   368   my $operand = shift;

   369 

   370   my @fromMapping = $self->FromMapping();

   371   my @toMapping  = $self->ToMapping();

   372   my $fromMappingSize = @fromMapping;

   373 

   374   unless($operand =~ /^\\.*/) {

   375     $operand = "\\"."$operand";  # Add a \\ to the beginning, which is equal to srcroot.

   376   }

   377 

   378   if(@fromMapping) {

   379     for(my $position = 0; $position<$fromMappingSize; $position++) {

   380       if($operand =~ /^\Q$fromMapping[$position]\E/i){

   381         $operand =~ s/^\Q$fromMapping[$position]\E/$toMapping[$position]/i;

   382         last;

   383       }

   384     }

   385   }

   386 

   387   return $operand;

   388 }

   389 

   390 sub PerformReverseMapOnFileName {

   391   my $self = shift;

   392   my $operand = shift;

   393 

   394   my @fromMapping = $self->FromMapping();

   395   my @toMapping  = $self->ToMapping();

   396   my $toMappingSize = @toMapping;

   397 

   398   unless($operand =~ /^\\(.*)/) {

   399     $operand = "\\"."$operand";  # Add a \\ to the beginning, which is equal to srcroot.

   400   }

   401 

   402   if(@toMapping) {

   403     for(my $position = 0; $position<$toMappingSize; $position++) {

   404       if($operand =~ /^\Q$toMapping[$position]\E/i){

   405         $operand =~ s/^\Q$toMapping[$position]\E/$fromMapping[$position]/i;

   406         last;

   407       }

   408     }

   409   }

   410 

   411   return $operand;

   412 }

   413 

   414 sub CheckFileNameForMappingClash {

   415   my $self = shift;

   416   my $fileName = shift;

   417 

   418   my @toMapping  = $self->ToMapping();

   419   my $dirName;

   420 

   421   if($fileName =~ /^(.*)\\/) {

   422     $dirName = $1;

   423   }

   424 

   425   if(@toMapping) {

   426     foreach my $toMap (@toMapping) {

   427       if($dirName =~ /^\Q$toMap\E/i) {

   428         die "ERROR: Clash in mappings. The local mapping $toMap clashes with the source directory $dirName.\n";

   429       }

   430     }

   431   }

   432 }

   433 

   434 sub RemoteSite {

   435   my $self = shift;

   436   my $verbose = shift;

   437   unless (defined $self->{remoteSite}) {

   438     my $module = 'RemoteSite::'.$self->RemoteSiteType();

   439     eval "require $module";

   440     $self->{remoteSite} = $module->New(host => $self->RemoteHost(),

   441                username => $self->RemoteUsername(),

   442                password => $self->RemotePassword(),

   443                passive_mode => $self->PasvTransferMode(),

   444                resume_mode => $self->FtpServerSupportsResume(),

   445                proxy => $self->Proxy(),

   446                proxy_username => $self->ProxyUsername(),

   447                proxy_password => $self->ProxyPassword(),

   448                max_export_volume_size => $self->MaxExportVolumeSize(),

   449                verbose => $verbose);

   450     die "Failed to create remote site object" unless ref $self->{remoteSite};

   451   }

   452   return $self->{remoteSite};

   453 }

   454 

   455 sub LocalArchivePath {

   456   require Carp;

   457   Carp->import;

   458   confess ("Obsolete method called");

   459 }

   460 

   461 sub RemoteArchivePath {

   462   require Carp;

   463   Carp->import;

   464   confess ("Obsolete method called");

   465 }

   466 

   467 sub ArchivePathFile {

   468   require Carp;

   469   Carp->import;

   470   confess ("Obsolete method called");

   471 }

   472 

   473 sub ListArchiveComponents {

   474   require Carp;

   475   Carp->import;

   476   confess ("Obsolete method called");

   477 }

   478 

   479 sub BinariesToIgnore {

   480   my $self = shift;

   481   if (exists $self->{binIgnore}) {

   482     return $self->{binIgnore};

   483   }

   484   return [];

   485 }

   486 

   487 sub DisallowUnclassifiedSource {

   488   my $self = shift;

   489   if (exists $self->{disallow_unclassified_source}) {

   490     return 1;

   491   }

   492   return 0;

   493 }

   494 

   495 sub Win32ExtensionsDisabled {

   496   my $self = shift;

   497   

   498   if (exists $self->{disable_win32_extensions}) {

   499     return 1;

   500   }

   501   return 0;

   502 }

   503 

   504 sub CategoriseBinaries {

   505   my $self = shift;

   506   if (exists $self->{categorise_binaries}) {

   507     return 1;

   508   }

   509   return 0;

   510 }

   511 

   512 sub CategoriseExports {

   513   my $self = shift;

   514   if (exists $self->{categorise_exports}) {

   515     return 1;

   516   }

   517   return 0;

   518 }

   519 

   520 sub RequiredBinaries {

   521   my $self = shift;

   522   my $component = lc(shift);

   523   if (exists $self->{required_binaries}->{$component}) {

   524     return $self->{required_binaries}->{$component};

   525   }

   526   elsif (exists $self->{required_binaries}->{default}) {

   527     return $self->{required_binaries}->{default};

   528   }

   529   return undef;

   530 }

   531 

   532 sub TableFormatter {

   533   my $self = shift;

   534   require TableFormatter;

   535   require POSIX;

   536   # Not 'use' because not many commands draw tables so that would be a waste

   537 

   538   if (!POSIX::isatty('STDOUT')) {

   539     $self->{table_format} = "text";

   540     $self->{table_format_args} = "";

   541   }

   542 

   543   unless (defined $self->{table_formatter}) {

   544     my $format = $self->{table_format} || "text";

   545     $self->{table_formatter} = TableFormatter::CreateFormatter($format, $self, $self->{table_format_args});

   546   }

   547 

   548   return $self->{table_formatter};

   549 }

   550 

   551 sub LatestVerFilter {

   552   my $self = shift;

   553   unless (exists $self->{latestver_filter}) {

   554     return undef;

   555   }

   556   return $self->{latestver_filter};

   557 }

   558 

   559 sub IllegalWorkspaceVolumes {

   560   my $self = shift;

   561   if (defined $self->{illegal_workspace_volumes}) {

   562     return @{$self->{illegal_workspace_volumes}};

   563   }

   564   return ();

   565 }

   566 

   567 #

   568 # Private

   569 #

   570 

   571 sub CheckMappingPath {

   572   my $self = shift;

   573   my $operand = shift;

   574 

   575   # Is used to clean up the mapping path.

   576 

   577   $operand =~ s/\//\\/g;

   578 

   579   die "Error: The source_map path $operand must not include a drive letter.\n" if ($operand =~ /^.:/);

   580   die "Error: The source_map path $operand must be an absolute path without a drive letter.\n" if ($operand !~ /^\\/);

   581   die "Error: The source_map path $operand must not be a UNC path.\n" if ($operand =~ /^\\\\/);

   582 

   583   #Remove any \\ at the end of the path.

   584   if($operand =~ /(.*)\\$/){

   585     $operand = $1;

   586   }

   587 

   588   return $operand;

   589 }

   590 

   591 sub BuildSystemVersion {

   592   my $self = shift;

   593   my $verbose = shift;

   594   

   595   if (exists $self->{sbs_version}) {

   596   	print "User set the value of sbs_version to $self->{sbs_version}\n" if($verbose);

   597     return $self->{sbs_version};

   598   }

   599   return "0";

   600 }

   601 

   602 sub ExtractMapping {

   603   my $self = shift;

   604   my $operand = shift;

   605   my $epoc32dir = Utils::EpocRoot()."epoc32";

   606 

   607   $operand =~ s/\s+$//;

   608 

   609   if ($operand =~ /^(\S+)\s+(\S+)$/) {

   610     my $archivePath = $self->CheckMappingPath($1);

   611     my $localPath = $self->CheckMappingPath($2);

   612 

   613     if($archivePath =~ /^\Q$epoc32dir\E/i){

   614       die "ERROR: Archive path $epoc32dir... in source mapping is not allowed.\n";

   615     }

   616     elsif($localPath =~ /^\Q$epoc32dir\E/i){

   617       die "ERROR: Local path $epoc32dir... in source mapping is not allowed.\n";

   618     }

   619 

   620     # Need to check whether the from location is already present in from_mapping array

   621     if(defined @{$self->{from_mapping}}){

   622       foreach my $fromMap (@{$self->{from_mapping}}) {

   623         if(($archivePath =~ /^\W*\Q$fromMap\E\W*$/i) || ($fromMap =~ /^\W*\Q$archivePath\E\W*$/i)){

   624           die "ERROR: Duplicate <archive_source_directory> $fromMap, <archive_source_directory> $archivePath found in source mappings.\n";

   625   }

   626       }

   627     }

   628 

   629     # Need to check whether the to location is already present in to_mapping array

   630     if(defined @{$self->{to_mapping}}){

   631       foreach my $toMap (@{$self->{to_mapping}}) {

   632         if(($localPath =~ /^\W*\Q$toMap\E\W*$/i) || ($toMap =~ /^\W*\Q$localPath\E\W*$/i)){

   633           die "ERROR: Duplicate <local_source_directory> $toMap, <local_source_directory> $localPath found in source mappings.\n";

   634     }

   635       }

   636     }

   637 

   638     push @{$self->{from_mapping}}, $archivePath;

   639     push @{$self->{to_mapping}}, $localPath;

   640   }

   641   else{

   642     die "ERROR: Incorrect usage of source_map keyword in reltools.ini. Expected input is source_map <archive_source_directory> <local_source_directory>\n";

   643   }

   644 }

   645 

   646 sub ReadIni {

   647   my $self = shift;

   648 

   649   open (INI, $self->{iniFileName}) or die "Unable to open \"$self->{iniFileName}\" for reading: $!\n";

   650 

   651   while (local $_ = <INI>) {

   652     # Remove line feed, white space and comments.

   653     chomp;

   654     s/^\s*$//;

   655     

   656     # INC105677 - Warn user if remote_password contains an unescaped #

   657     if (/remote_password\s+\S*[^\\\s]\#/) {

   658       warn "Warning: remote_password appears to contain a comment (# characters need to be escaped)\n";

   659     }

   660     

   661     s/(?<!\\)#.*//; # remove comments unless they are immediately preceded by \ (negative lookbehind assertion)

   662     s/\\#/#/g; # now remove backslashes before # signs

   663     

   664     if ($_ eq '') {

   665       # Nothing left.

   666       next;

   667     }

   668 

   669     my $keyWord;

   670     my $operand;

   671     if (/^(\w+)\s+(.*)/) {

   672       $keyWord = $1;

   673       $operand = $2;

   674     }

   675     else {

   676       # Must be a line with no operand.

   677       $keyWord = $_;

   678     }

   679 

   680     unless (defined $keyWord) {

   681       die "Error: Invalid line in \"$self->{iniFileName}\":\n\t$_\n";

   682       next;

   683     }

   684 

   685     if ($keyWord =~ /^diff_tool$/i) {

   686       Utils::StripWhiteSpace(\$operand);

   687       $self->{diff_tool} = $operand;

   688     }

   689     elsif ($keyWord =~ /^require_internal_versions$/) {

   690       $self->{require_internal_versions} = 1;

   691     }

   692     elsif ($keyWord =~ /^ignore_source_filter_errors$/) {

   693       $self->{ignore_source_filter_errors} = 1;

   694     }

   695     elsif ($keyWord =~ /^html_notes$/) {

   696       $self->{html_notes} = 1;

   697     }

   698     elsif ($keyWord =~ /^temp_dir$/) {

   699       Utils::StripWhiteSpace(\$operand);

   700       $operand = File::Spec->catdir($operand);

   701       $operand =~ s/[\\\/]$//;

   702       if (!-d $operand  && length $operand) {

   703         die "Error: Invalid line in \"$self->{iniFileName}\":\n\t$_\n$operand does not exist or is an invalid directory name\n";

   704       }

   705       $self->{temp_dir} = $operand;

   706     }   

   707     elsif ($keyWord =~ /^remote_site_type$/) {

   708       Utils::StripWhiteSpace(\$operand);

   709       $self->{remote_site_type} = $operand;

   710     }

   711     elsif ($keyWord =~ /^remote_host$/) {

   712       Utils::StripWhiteSpace(\$operand);

   713       $self->{remote_host} = $operand;

   714     }

   715     elsif ($keyWord =~ /^remote_username$/) {

   716       Utils::StripWhiteSpace(\$operand);

   717       $self->{remote_username} = $operand;

   718     }

   719     elsif ($keyWord =~ /^remote_password$/) {

   720       Utils::StripWhiteSpace(\$operand);

   721       $self->{remote_password} = $operand;

   722     }

   723     elsif ($keyWord =~ /^remote_logs_dir$/) {

   724       Utils::StripWhiteSpace(\$operand);

   725       $self->{remote_logs} = $operand;

   726     }

   727     elsif ($keyWord =~ /^pgp_tool$/) {

   728       Utils::StripWhiteSpace(\$operand);

   729       $self->{pgp_tool} = $operand;

   730     }

   731     elsif ($keyWord =~ /^pgp_encryption_key$/) {

   732       Utils::StripWhiteSpace(\$operand);

   733       push @{$self->{pgp_encryption_keys}}, $operand;

   734     }

   735     elsif ($keyWord =~ /^pgp_config_path$/) {

   736       Utils::StripWhiteSpace(\$operand);

   737       $self->{pgp_config_path} = $operand;

   738     }

   739     elsif ($keyWord =~ /^export_data_file$/) {

   740       Utils::StripWhiteSpace(\$operand);

   741       $self->{export_data_file} = $operand;

   742     }

   743     elsif ($keyWord =~ /^archive_path_file$/) {

   744       $self->PathData->ProcessLine(\$keyWord, \$operand);

   745     }

   746     elsif ($keyWord =~ /^archive_path$/) {

   747       $self->PathData->ProcessLine(\$keyWord, \$operand);

   748     }

   749     elsif ($keyWord =~ /^source_map$/) {

   750        $self->ExtractMapping($operand);

   751     }

   752     elsif ($keyWord =~ /^no_ini_location_warning$/) {

   753       $self->{warnIniLocation} = 0;

   754     }

   755     elsif ($keyWord =~ /^ignore_binary$/) {

   756       Utils::StripWhiteSpace(\$operand);

   757       push (@{$self->{binIgnore}}, $operand);

   758     }

   759     elsif ($keyWord =~ /^proxy$/) {

   760       Utils::StripWhiteSpace(\$operand);

   761       $self->{proxy} = $operand;

   762     }

   763     elsif ($keyWord =~ /^proxy_username$/) {

   764       Utils::StripWhiteSpace(\$operand);

   765       $self->{proxy_username} = $operand;

   766     }

   767     elsif ($keyWord =~ /^proxy_password$/) {

   768       Utils::StripWhiteSpace(\$operand);

   769       $self->{proxy_password} = $operand;

   770     }

   771     elsif ($keyWord =~ /^pasv_transfer_mode$/) {

   772       $self->{pasv_transfer_mode} = 1;

   773     }

   774     elsif ($keyWord =~ /^ftp_server_supports_resume$/) {

   775       $self->{ftp_server_supports_resume} = 1;

   776     }

   777     elsif ($keyWord =~ /^ftp_timeout$/) {

   778       Utils::StripWhiteSpace(\$operand);

   779       $self->{ftp_timeout} = $operand;

   780     }

   781     elsif ($keyWord =~ /^ftp_reconnect_attempts$/) {

   782       Utils::StripWhiteSpace(\$operand);

   783       $self->{ftp_reconnect_attempts} = $operand;

   784     }

   785     elsif ($keyWord =~ /^max_export_volume_size$/) {

   786       Utils::StripWhiteSpace(\$operand);

   787       $self->{max_export_volume_size} = $operand;

   788     }

   789     elsif ($keyWord =~ /^disallow_unclassified_source$/) {

   790       $self->{disallow_unclassified_source} = 1;

   791     }

   792     elsif ($keyWord =~ /^disable_win32_exten[ts]ions$/) {

   793       $self->{disable_win32_extensions} = 1;

   794     }

   795     elsif ($keyWord =~ /^categori[sz]e_binaries$/) {

   796       $self->{categorise_binaries} = 1;

   797     }

   798     elsif ($keyWord =~ /^categori[sz]e_exports$/) {

   799       $self->{categorise_exports} = 1;

   800     }

   801     elsif ($keyWord =~ /^latestver_filter$/) {

   802       Utils::StripWhiteSpace(\$operand);

   803       require Text::Glob;

   804       $self->{latestver_filter} = Text::Glob::glob_to_regex($operand);;

   805     }    

   806     elsif ($keyWord =~ /^required_binaries$/) {

   807       Utils::StripWhiteSpace(\$operand);

   808       (my $component, my $required, my $dummy) = split (/\s+/, $operand);

   809       if ($dummy or not ($component and $required)) {

   810         die "Error: Invalid line in \"$self->{iniFileName}\":\n\t$_\n";

   811         next;

   812       }

   813       push (@{$self->{required_binaries}->{lc($component)}}, lc($required));

   814     }

   815     #Support for target alias file

   816     elsif ($keyWord =~ /^no_target_alias_warning$/) {

   817       $self->{mustWarnTargetAliasLocation} = 0;

   818     }

   819     elsif ($keyWord =~ /^table_format$/) {

   820       Utils::StripWhiteSpace(\$operand);

   821       (my $format, my $args) = $operand =~ m/^(\w+)(.*)$/;

   822       Utils::StripWhiteSpace(\$args);

   823       $self->{table_format} = $format;

   824       $self->{table_format_args} = $args;

   825     }

   826     elsif ($keyWord =~ /^illegal_workspace_volumes$/) {

   827       Utils::StripWhiteSpace(\$operand);

   828       if ($operand !~ /^[a-z\s,]+$/i) {

   829         die "Error: Invalid line in \"$self->{iniFileName}\":\n\t$_\n";

   830       }

   831       @{$self->{illegal_workspace_volumes}} = split /\s*,\s*/,$operand;

   832     }

   833     elsif ($keyWord =~ /^use_distribution_policy_files_first/) {

   834       $self->{use_distribution_policy_files_first} = 1;

   835     }

   836     elsif ($keyWord =~ /^csv_separator$/) {

   837       Utils::StripWhiteSpace(\$operand);

   838       $self->{csv_separator} = $operand;

   839     }

   840     elsif ($keyWord =~ /^sbs_version$/) {

   841       Utils::StripWhiteSpace(\$operand);

   842       $self->{sbs_version} = $operand;

   843     }

   844     else {

   845       die "Error: Unknown keyword \"$keyWord\" in \"$self->{iniFileName}\"\n";

   846     }

   847   }

   848   

   849   close (INI);

   850 

   851   if ($self->{warnIniLocation}) {

   852     if (defined $$envDir){

   853        print "Warning: \"$$iniName\" not found in \"$$envDir\", using version found in \"$$binDir\"\n";

   854     } else {

   855        print "Warning: Using \"$$iniName\" version found in \"$$binDir\"\n";

   856     }

   857     print "         Use the keyword \"no_ini_location_warning\" to disable this warning.\n";

   858   }

   859 }

   860 

   861 sub ReadTargetAliasFile {

   862   my $self = shift;

   863   

   864   if (-e $self->{targetAliasName}) {

   865     open (ALIAS, $self->{targetAliasName}) or die "Unable to open \"$self->{targetAliasName}\" for reading: $!\n";

   866     # %allValuesSeenSoFar is a temporary hash of all the values seen so far

   867     my %allValuesSeenSoFar = ();

   868     # %aliasMap is the final hash of keys to values with all aliases expanded out

   869     my %aliasMap = ();

   870     $self->{alias_map} = {};

   871     while (local $_ = <ALIAS>) {

   872       # Remove line feed, white space and comments.

   873       chomp;

   874       s/^\s*$//;

   875       s/(?<!\\)#.*//; # remove comments unless they are immediately preceded by \ (negative lookbehind assertion)

   876       s/\\#/#/g; # now remove backslashes before # signs

   877       if ($_ eq '') {

   878         # Nothing left.

   879         next;

   880       }

   881       my $keyWord;        # The key field

   882       my @valueList;      # The list of values as read from the line.

   883       my %seen = ();      # Temporary hash for making values on the line unique

   884       if (/^\s*(\S+)\s+(.+)/) {

   885         # Uppercase significant

   886         $keyWord = uc($1);

   887         @valueList = split /\s+/, uc($2);

   888         # Check the key for:

   889         # A key that has been seen as already as a value i.e. a forward reference - fatal error

   890         # A key that has been seen as already as a key i.e. a duplicate key - fatal error

   891         if (exists $allValuesSeenSoFar{$keyWord}) {

   892           die "Fatal error: Line \"$_\" in $self->{targetAliasName} has forward reference to \"$keyWord\"\n";

   893         }

   894         elsif (exists $self->{alias_map}->{$keyWord}) {

   895           die "Fatal error: Line \"$_\" in $self->{targetAliasName} has duplicate key \"$keyWord\"\n";

   896         }

   897         # Check for:

   898         # Circular references - fatal error

   899         # Duplicates in the value list - warn and ignore

   900         foreach my $value (@valueList) {

   901           if ($value eq $keyWord) {

   902             die "Fatal error: Line \"$_\" in $self->{targetAliasName} has circular reference in \"$keyWord\"\n"

   903           }

   904           elsif (exists $seen{$value}) {

   905             print "Warning Line \"$_\" in $self->{targetAliasName} has duplicate value entry \"$value\" in key $keyWord\n";

   906           }

   907           else {

   908             # Add to seen map and uniqueList

   909             $seen{$value} = 1;

   910             $allValuesSeenSoFar{$value} = 1;

   911           }

   912         }

   913         my @resolvedList = ();  # Resolved aliases

   914         # Check for the special use of the value '<EMPTY>'

   915         # If this is present then there must be no other values.

   916         if (exists $seen{"<EMPTY>"}) {

   917           if (scalar (keys %seen) > 1) {

   918             die "Fatal error: Multiple targets in list declared \"<EMPTY>\" for alias \"$keyWord\"\n";

   919           }

   920         } else {

   921           # Now can expand the unique list by resolving aliases against existing keys

   922           foreach my $uniqueLine (keys %seen) {

   923             if (exists $self->{alias_map}->{$uniqueLine}) {

   924               # Expand the list to resolve the aliases

   925               push(@resolvedList, @{$self->{alias_map}->{$uniqueLine}});

   926             }

   927             else {

   928               # No alias resolution required, just add it

   929               push(@resolvedList, $uniqueLine);

   930             }

   931           }

   932         }

   933         # Add the resolved list to the aliasMap

   934         push( @{$self->{alias_map}->{$keyWord}}, @resolvedList);

   935       }

   936       else {

   937         # A line with no value is illegal.

   938         # Grab the key word

   939         if (/^\s*(\S+)/) {

   940           # Make uppercase as HasTargetPlatforms(), TargetPlatforms()

   941           # expects uppercase keys

   942           $keyWord = uc($1);

   943         } else {

   944           die "Fatal error: Fatal parser error.\n"

   945         }

   946         die "Fatal error: No targets detected for \"$keyWord\"\n"

   947       }

   948     unless (defined $keyWord) {

   949       die "Error: Invalid line in \"$self->{targetAliasName}\":\n\t$_\n";

   950       next;

   951     }

   952   }

   953   close (ALIAS);

   954   } else {

   955     # Failed to find target alias file

   956     return 0;

   957   }

   958   return 1; # Success at reading the file

   959 }

   960 

   961 # Support for target alias file

   962 # Returns 1 if target platforms exist for a given alias

   963 # or 0 if no target platforms exist for a given alias

   964 sub HasTargetPlatforms {

   965   my $self = shift;

   966   my $alias = shift;

   967   $alias = uc($alias);

   968   $self->CheckAliasWarning();

   969   if (exists $self->{alias_map}) {

   970     if (exists $self->{alias_map}->{$alias}) {

   971       return 1;

   972     }

   973   }

   974   return 0;

   975 }

   976 

   977 # Support for target alias file

   978 # Returns the arrary of target platforms for a given alias

   979 # or undef if no target platforms for a given alias

   980 sub TargetPlatforms {

   981   my $self = shift;

   982   my $alias = shift;

   983   $self->CheckAliasWarning();

   984   $alias = uc($alias);

   985   if (exists $self->{alias_map}) {

   986     if (exists $self->{alias_map}->{$alias}) {

   987       return $self->{alias_map}->{$alias};

   988     }

   989   }

   990   # Nothing found so return the callers argument

   991   return [$alias];

   992 }

   993 

   994 sub CheckAliasWarning {

   995   my $self = shift;

   996   if ($self->{mustWarnTargetAliasLocation} == 1) {

   997     print "Warning: \"$self->{targetAliasName}\" not found.\n";

   998     print "         Use the keyword \"no_target_alias_warning\" to disable this warning.\n";

   999    }

  1000   $self->{mustWarnTargetAliasLocation} = 0;

  1001 }

  1002 

  1003 sub UseDistributionPolicyFilesFirst {

  1004   my $self = shift;

  1005   return !!$self->{use_distribution_policy_files_first};

  1006 }

  1007 

  1008 sub CsvSeparator {

  1009   my $self = shift;

  1010   

  1011   if (defined $self->{csv_separator}) {

  1012     return $self->{csv_separator};

  1013   }

  1014   

  1015   return ',';

  1016 }

  1017 

  1018 1;

  1019 

  1020 __END__

  1021 

  1022 =head1 NAME

  1023 

  1024 IniData.pm - Provides an interface to the data contained in reltools.ini.

  1025 

  1026 =head1 INTERFACE

  1027 

  1028 =head2 New

  1029 

  1030 Expects to find a file named F<reltools.ini> in the release tools directory, dies if it can't. Parses this file according to the following keywords / value pairs:

  1031 

  1032  require_internal_versions

  1033  ignore_source_filter_errors

  1034  no_ini_location_warning

  1035  disallow_unclassified_source

  1036  categorise_binaries

  1037  categorise_exports

  1038  html_notes

  1039  archive_path                <archive_name> <archive_path> [<remote_archive_path>]

  1040  diff_tool                   <tool_name>

  1041  export_data_file            <file_name>

  1042  archive_path_file           <file_name>

  1043  source_map                  <archive_source_directory> <local_source_directory>

  1044  remote_site_type            <server_type>

  1045  remote_host                 <host_name>

  1046  remote_username             <user_name>

  1047  remote_password             <pass_word>

  1048  remote_logs_dir             <path>

  1049  pasv_transfer_mode

  1050  ftp_server_supports_resume

  1051  ftp_timeout                 <time_in_seconds>

  1052  ftp_reconnect_attempts      <positive_integer>

  1053  proxy                       <host_name>

  1054  proxy_username              <user_name>

  1055  proxy_password              <pass_word>

  1056  pgp_tool                    <tool_name>

  1057  pgp_encryption_key          <keyid>

  1058  pgp_config_path             <dir_name>

  1059  ignore_binary               <wild_file_name>

  1060  required_binaries           default wins_udeb

  1061  required_binaries           default thumb_urel

  1062  table_format                <table_format module>

  1063  csv_separator               <csv_separator_character>

  1064  sbs_version                 <symbian_build_system>

  1065 

  1066 It assumes # indicates the start of a comment, unless it is preceded by \.

  1067 

  1068 =head2 DiffTool

  1069 

  1070 Returns the name of the differencing tool specified with the C<diff_tool> keyword.

  1071 

  1072 =head2 RequireInternalVersions

  1073 

  1074 Returns true or false depending on whether the C<require_internal_versions> keyword has been specified.

  1075 

  1076 =head2 IgnoreSourceFilterErrors

  1077 

  1078 Returns true or false depending on whether the C<ignore_source_filter_errors> keyword has been specified.

  1079 

  1080 =head2 RemoteSiteType

  1081 

  1082 Returns the type of server hosting the projects remote release archive. Currently this will return either C<'FTP'>, C<'FTP::Proxy'>, C<'NetDrive'>, C<'NetDrive::MultiVolumeExport'> or C<'NetDrive::MultiVolumeImport'>. The default return value is C<'FTP'> if not set.

  1083 

  1084 =head2 RemoteHost

  1085 

  1086 Returns the host address of the project's remote site. If the remote site is an ftp server this will be an ftp address; if it is a network drive then the return value will be a UNC path.

  1087 

  1088 =head2 RemoteUsername

  1089 

  1090 Returns the username for the project's remote site.

  1091 

  1092 =head2 RemotePassword

  1093 

  1094 Returns the password for the project's remote site.

  1095 

  1096 =head2 RemoteLogsDir

  1097 

  1098 Returns the directory on the project's remote site where release notification logs are to be written.

  1099 

  1100 =head2 PasvTransferMode

  1101 

  1102 Returns true or false depending on whether the C<pasv_transfer_mode> keyword has been specified.

  1103 

  1104 =head2 FtpServerSupportsResume

  1105 

  1106 Returns true or false depending on whether the C<ftp_server_supports_resume> keyword has been specified.

  1107 

  1108 =head2 FtpTimeout

  1109 

  1110 Returns the timeout in seconds allowed before dropping the connection to the FTP server

  1111 

  1112 =head2 FtpReconnectAttempts

  1113 

  1114 Returns the number of attempts to reconnect to the FTP site if the connection is dropped

  1115 

  1116 =head2 Proxy

  1117 

  1118 Returns the FTP address of a proxy server used to connect to the project's FTP site.

  1119 

  1120 =head2 ProxyUsername

  1121 

  1122 Returns the username for a proxy server used to connect to the project's FTP site.

  1123 

  1124 =head2 ProxyPassword

  1125 

  1126 Returns the password for a proxy server used to connect to the project's FTP site.

  1127 

  1128 =head2 RemoteSite

  1129 

  1130 Tries to create a RemoteSite object appropriate to the data in the iniData, and return it. Caches the RemoteSite object so that it is only created once.

  1131 

  1132 =head2 MaxExportVolumeSize

  1133 

  1134 Returns the value specified by the keyword C<max_export_volume_size>. If this has not been specified, returns 639 * 1024 * 1024.