718 lines
23 KiB
C
718 lines
23 KiB
C
/*
|
|
* CDE - Common Desktop Environment
|
|
*
|
|
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
|
|
*
|
|
* These libraries and programs are free software; you can
|
|
* redistribute them and/or modify them under the terms of the GNU
|
|
* Lesser General Public License as published by the Free Software
|
|
* Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*
|
|
* These libraries and programs are distributed in the hope that
|
|
* they will be useful, but WITHOUT ANY WARRANTY; without even the
|
|
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
* PURPOSE. See the GNU Lesser General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with these libraries and programs; if not, write
|
|
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
* Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
/* $XConsortium: SmMigResources.c /main/4 1996/05/08 20:11:34 drk $ */
|
|
static char sccsid[] = "@(#)48 1.2 src/cde/cde1/dtsession/SmMigResources.c, desktop, cde41J, 9520A_all 5/16/95 08:31:12";
|
|
/*
|
|
* COMPONENT_NAME: desktop
|
|
*
|
|
* FUNCTIONS: MigrateResources
|
|
*
|
|
* ORIGINS: 27
|
|
*
|
|
* IBM CONFIDENTIAL -- (IBM Confidential Restricted when
|
|
* combined with the aggregated modules for this product)
|
|
* OBJECT CODE ONLY SOURCE MATERIALS
|
|
*
|
|
* (C) COPYRIGHT International Business Machines Corp. 1995
|
|
* All Rights Reserved
|
|
* US Government Users Restricted Rights - Use, duplication or
|
|
* disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <Dt/DtNlUtils.h>
|
|
|
|
/* defines for return codes */
|
|
#define RC_SUCCESS 0
|
|
#define RC_OPEN_ERROR 1
|
|
#define RC_END_OF_FILE 2
|
|
#define RC_MEMORY_ALLOCATION_ERROR 3
|
|
#define RC_LINE_CONTINUED 4
|
|
#define RC_PARTIAL_LINE 5
|
|
#define RC_WRITE_ERROR_TEMP 6
|
|
|
|
/* type 1 resources are of the form:
|
|
[*.]convert1[i]
|
|
|
|
Example of a resource specification of this type:
|
|
*foreground: Blue
|
|
*/
|
|
#define NUMBER_OF_CONVERT1 15
|
|
static char *convert1[NUMBER_OF_CONVERT1]
|
|
= {
|
|
"displayResolution",
|
|
"systemFont",
|
|
"userFont",
|
|
"FontList",
|
|
"Font",
|
|
"FontSet",
|
|
"multiClickTime",
|
|
"sessionVersion",
|
|
"background",
|
|
"foreground",
|
|
"ColorUse",
|
|
"HelpColorUse",
|
|
"background",
|
|
"foreground",
|
|
"enableBtn1Transfer"
|
|
}
|
|
;
|
|
|
|
|
|
/* type 2 resources are of the form:
|
|
CONVERT2_0{* or .}CONVERT2_1{* or .}convert2[i]
|
|
|
|
Example of a resource specification of this type:
|
|
dtsession*extension*cycleTimeout: 10
|
|
*/
|
|
#define CONVERT2_0 "dtsession"
|
|
#define CONVERT2_1 "extension"
|
|
#define NUMBER_OF_CONVERT2 5
|
|
static char *convert2[NUMBER_OF_CONVERT2]
|
|
= {
|
|
"cycleTimeout",
|
|
"lockTimeout",
|
|
"saverTimeout",
|
|
"random",
|
|
"saverList",
|
|
}
|
|
;
|
|
|
|
|
|
/* type 3 resources are of the form:
|
|
convert31[i]{* or .}convert32[i]
|
|
|
|
Example of a resource specification of this type:
|
|
Dtwm*useIconBox: True
|
|
*/
|
|
#define NUMBER_OF_CONVERT3 26
|
|
static char *convert31[NUMBER_OF_CONVERT3]
|
|
= {
|
|
"dtsession",
|
|
"dtsession",
|
|
"dtsession",
|
|
"dtsession",
|
|
"dtsession",
|
|
"dtsession",
|
|
"Dtstyle",
|
|
"Dtstyle",
|
|
"Dtwm",
|
|
"Dtwm",
|
|
"Dtwm",
|
|
"Dtwm",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"wsHelp",
|
|
"cachedHelp"
|
|
}
|
|
;
|
|
static char *convert32[NUMBER_OF_CONVERT3]
|
|
= {
|
|
"displayResolution" ,
|
|
"sessionLanguage" ,
|
|
"saverTimeout" ,
|
|
"cycleTimeout" ,
|
|
"lockTimeout" ,
|
|
"saverList" ,
|
|
"lockoutScale" ,
|
|
"timeoutScale" ,
|
|
"keyboardFocusPolicy",
|
|
"focusAutoRaise" ,
|
|
"moveOpaque" ,
|
|
"useIconBox" ,
|
|
"onScreen" ,
|
|
"x" ,
|
|
"y" ,
|
|
"columns" ,
|
|
"rows" ,
|
|
"helpType" ,
|
|
"vPCount" ,
|
|
"tTitle" ,
|
|
"helpVolume" ,
|
|
"locationId" ,
|
|
"stringData" ,
|
|
"windowGroup" ,
|
|
"wsName" ,
|
|
"cachedCount"
|
|
}
|
|
;
|
|
|
|
/* type 4 resources are of the form:
|
|
{* or .}convert4[i]{* or .}CONVERT4_2
|
|
|
|
Example of a resource specification of this type:
|
|
*XmText*FontList: Big
|
|
*/
|
|
#define CONVERT4_2 "FontList"
|
|
#define NUMBER_OF_CONVERT4 2
|
|
static char *convert4[NUMBER_OF_CONVERT4]
|
|
= {
|
|
"XmText",
|
|
"XmTextField"
|
|
}
|
|
;
|
|
|
|
|
|
/* type 5 resources are of the form:
|
|
convert5[i]{* or .}<any value>{* or .}CONVERT5_2
|
|
|
|
Example of a resource specification of this type:
|
|
Dtwm*0*helpResources: xxx
|
|
*/
|
|
#define CONVERT5_2 "helpResources"
|
|
#define NUMBER_OF_CONVERT5 2
|
|
/* these are of the form p1*#*helpResources */
|
|
static char *convert5[NUMBER_OF_CONVERT5]
|
|
= {
|
|
"Dtwm",
|
|
"Mwm"
|
|
}
|
|
;
|
|
|
|
|
|
/* type 6 resources are of the form:
|
|
CONVERT6_0<any value>{* or .}convert6[i]
|
|
|
|
Example of a resource specification of this type:
|
|
oWsHelp10*x: xxx
|
|
*/
|
|
#define CONVERT6_0 "oWsHelp"
|
|
#define NUMBER_OF_CONVERT6 11
|
|
static char *convert6[NUMBER_OF_CONVERT6]
|
|
= {
|
|
"x",
|
|
"y",
|
|
"columns",
|
|
"rows",
|
|
"helpType",
|
|
"vPCount",
|
|
"tTitle",
|
|
"helpVolume",
|
|
"locationId",
|
|
"stringData",
|
|
"workspaces"
|
|
}
|
|
;
|
|
|
|
/* type 7 resources are of the form:
|
|
CONVERT7_01{* or .}<any value>{* or .}convert7[i]
|
|
- or -
|
|
CONVERT7_02{* or .}<any value>{* or .}convert7[i]
|
|
|
|
Examples of resource specifications of this type:
|
|
Dtwm*0*initialWorkspace: xxx
|
|
Mwm*0*initialWorkspace: xxx
|
|
*/
|
|
#define CONVERT7_01 "Mwm"
|
|
#define CONVERT7_02 "Dtwm"
|
|
#define NUMBER_OF_CONVERT7 3
|
|
/* these are of the form Mwm|Dtwm*XXX*resource */
|
|
static char *convert7[NUMBER_OF_CONVERT7]
|
|
= {
|
|
"initialWorkspace",
|
|
"workspaceList",
|
|
"workspaceCount"
|
|
}
|
|
;
|
|
|
|
/* type 8 resources are of the form:
|
|
CONVERT8_01{* or .}<any value>{* or .}<any value>{* or .}convert8[i]
|
|
- or -
|
|
CONVERT8_02{* or .}<any value>{* or .}<any value>{* or .}convert8[i]
|
|
|
|
Examples of resource specifications of this type:
|
|
Mwm*0*ws01*title: xxx
|
|
Dtwm*1ws02*title: xxx
|
|
*/
|
|
#define CONVERT8_01 "Mwm"
|
|
#define CONVERT8_02 "Dtwm"
|
|
#define NUMBER_OF_CONVERT8 3
|
|
static char *convert8[NUMBER_OF_CONVERT8]
|
|
= {
|
|
"title",
|
|
"geometry",
|
|
"iconBoxGeometry"
|
|
}
|
|
;
|
|
|
|
/* type 9 resources are of the form:
|
|
CONVERT9_01{* or .}<any value>{* or .}<any value>{* or .}convert91[i] \
|
|
{* or .}convert92[i]
|
|
- or -
|
|
CONVERT9_02{* or .}<any value>{* or .}<any value>{* or .}convert91[i] \
|
|
{* or .}convert92[i]
|
|
|
|
Example of resource specification of this type:
|
|
Dtwm*0*ws01*backdrop*image: Drops
|
|
*/
|
|
#define CONVERT9_01 "Mwm"
|
|
#define CONVERT9_02 "Dtwm"
|
|
#define NUMBER_OF_CONVERT9 3
|
|
static char *convert91[NUMBER_OF_CONVERT9]
|
|
= {
|
|
"backdrop",
|
|
"FrontPanel",
|
|
"MyFrontPanel"
|
|
}
|
|
;
|
|
|
|
static char *convert92[NUMBER_OF_CONVERT9]
|
|
= {
|
|
"image" ,
|
|
"geometry",
|
|
"geometry"
|
|
}
|
|
;
|
|
|
|
|
|
|
|
/* type 10 resources are of the form:
|
|
*<any value>{* or .}convert10[i]
|
|
|
|
Example of a resource specification of this type:
|
|
*0*ColorPalette: Default.dp
|
|
*/
|
|
#define NUMBER_OF_CONVERT10 3
|
|
static char *convert10[NUMBER_OF_CONVERT10]
|
|
= {
|
|
"MonochromePalette",
|
|
"ColorUse",
|
|
"ColorPalette"
|
|
}
|
|
;
|
|
|
|
|
|
/* define the maximum fields in a resource specification
|
|
(which does not include the value of the resource) that
|
|
is required by this routine
|
|
*/
|
|
#define NUMBER_OF_FIELDS 6
|
|
static char * field[NUMBER_OF_FIELDS];
|
|
|
|
/* this function determines whether a field extracted from the resource
|
|
matches a string in the specified array.
|
|
Returns:
|
|
TRUE = if strings match
|
|
FALSE = if string do not match.
|
|
*/
|
|
int check_match1(char * match[], int noelements, int match1)
|
|
{
|
|
int i;
|
|
int matched = FALSE;
|
|
for (i=0;((matched == FALSE) &&
|
|
(i<noelements));i++)
|
|
{
|
|
if (strcmp(field[match1],match[i]) == 0)
|
|
{
|
|
matched =TRUE;
|
|
}
|
|
}
|
|
return(matched);
|
|
}
|
|
/* this function determines whether a fields extracted from the resource
|
|
match strings in the specified arrays.
|
|
Returns:
|
|
TRUE = if strings match
|
|
FALSE = if string do not match.
|
|
*/
|
|
int check_match2(char * match1_str[], char * match2_str[],
|
|
int noelements, int match1, int match2)
|
|
{
|
|
int i;
|
|
int matched = FALSE;
|
|
for (i=0;((matched == FALSE) &&
|
|
(i<noelements));i++)
|
|
{
|
|
|
|
if ((strcmp(field[match1],match1_str[i]) == 0) &&
|
|
(strcmp(field[match2],match2_str[i]) == 0))
|
|
{
|
|
matched =TRUE;
|
|
}
|
|
}
|
|
return(matched);
|
|
}
|
|
|
|
/* this function reads all resources from the input file.
|
|
If the resource matches those written from within desktop on 4.1.1 and
|
|
4.1.2, the resource is written to the output file.
|
|
Otherwise, the resource is not written to the output file.
|
|
|
|
Return codes:
|
|
RC_SUCCESS
|
|
RC_OPEN_ERROR
|
|
RC_MEMORY_ALLOCATION_ERROR
|
|
RC_WRITE_ERROR_TEMP
|
|
|
|
*/
|
|
MigrateResources(char * inputfile, char * outputfile)
|
|
{
|
|
|
|
int size_of_buffer = 1024;
|
|
int size_of_mbuffer = 1024;
|
|
int rc = RC_SUCCESS;
|
|
FILE * out_fh;
|
|
FILE * in_fh;
|
|
int write_line;
|
|
int chars_written;
|
|
int type_found = FALSE;
|
|
char * string;
|
|
char * realend;
|
|
int done=0;
|
|
int new_size = 0;
|
|
int number_fields = 0;
|
|
char * inputbuffer=NULL;
|
|
char * inputbuffer1=NULL;
|
|
char * unmodified_buffer=NULL;
|
|
char * resource_end;
|
|
char * first_space;
|
|
char * tmp1;
|
|
int i;
|
|
int charlen;
|
|
|
|
/* Initialize for multi-byte */
|
|
DtNlInitialize();
|
|
done = RC_SUCCESS;
|
|
/* open input and output files and exit if not successful */
|
|
in_fh = fopen(inputfile,"r");
|
|
out_fh = fopen(outputfile,"w");
|
|
if ((out_fh != NULL) && (in_fh != NULL))
|
|
{
|
|
|
|
/* allocate buffers for reading lines from the input file */
|
|
inputbuffer = malloc ((size_of_buffer + 1) * sizeof(char *));
|
|
inputbuffer1 = malloc ((size_of_buffer + 1) * sizeof(char *));
|
|
unmodified_buffer = malloc ((size_of_mbuffer + 1)
|
|
* sizeof(char *));
|
|
if ((inputbuffer != NULL) &&
|
|
(inputbuffer1 != NULL) &&
|
|
(unmodified_buffer != NULL))
|
|
{
|
|
do
|
|
{
|
|
|
|
*inputbuffer = '\0';
|
|
*inputbuffer1 = '\0';
|
|
*unmodified_buffer = '\0';
|
|
/* read and process each line from the input file */
|
|
do
|
|
|
|
{
|
|
/* read until an line has been read */
|
|
rc = RC_SUCCESS;
|
|
string = fgets((char *)inputbuffer1, size_of_buffer, in_fh);
|
|
|
|
/* if read was successful, then ...*/
|
|
if (string != NULL)
|
|
{
|
|
/* determine if a larger unmodified buffer
|
|
needs to be allocated
|
|
*/
|
|
new_size = strlen(unmodified_buffer) +
|
|
strlen(inputbuffer1) + 2;
|
|
|
|
if (new_size > size_of_mbuffer)
|
|
{
|
|
unmodified_buffer = realloc(unmodified_buffer,
|
|
new_size);
|
|
size_of_mbuffer = new_size;
|
|
}
|
|
|
|
/* save unmodified data read */
|
|
strcat(unmodified_buffer,inputbuffer1);
|
|
|
|
/* set indicator if entire line was not read */
|
|
DtLastChar(inputbuffer1,&realend,&charlen);
|
|
if ((charlen == 1) && (*realend != '\n'))
|
|
{
|
|
rc = RC_PARTIAL_LINE;
|
|
}
|
|
else
|
|
{
|
|
/* if entire line was read but it ends
|
|
with a continuation character
|
|
then, remove the ending continuation character or
|
|
spaces preceded by an ending
|
|
continuation character.
|
|
*/
|
|
realend=DtPrevChar(inputbuffer1,realend);
|
|
for (;((DtIsspace(realend) != 0) &&
|
|
(realend > inputbuffer1));)
|
|
{
|
|
realend=DtPrevChar(inputbuffer1,realend);
|
|
}
|
|
if ((mblen(realend,MB_CUR_MAX) == 1) &&
|
|
(*realend == '\\'))
|
|
{
|
|
*realend = '\0';
|
|
rc = RC_LINE_CONTINUED;
|
|
}
|
|
}
|
|
|
|
/* allocate larger input buffer if necessary */
|
|
new_size = strlen(inputbuffer) +
|
|
strlen(inputbuffer1) + 2;
|
|
|
|
if (new_size > size_of_buffer)
|
|
{
|
|
inputbuffer = realloc(inputbuffer,new_size);
|
|
size_of_buffer = new_size;
|
|
}
|
|
|
|
/* concatenate modified buffer to previously
|
|
read buffer
|
|
*/
|
|
strcat(inputbuffer,inputbuffer1);
|
|
}
|
|
else
|
|
{
|
|
rc = RC_END_OF_FILE;
|
|
}
|
|
} while ((rc == RC_LINE_CONTINUED) || (rc == RC_PARTIAL_LINE));
|
|
|
|
/* if read was successful, then determine if the resources
|
|
read are part of the set that need to be retained.
|
|
*/
|
|
type_found = FALSE;
|
|
number_fields = 0;
|
|
type_found=FALSE;
|
|
if (rc == RC_SUCCESS)
|
|
{
|
|
/* process non-comment lines */
|
|
if (strncmp(inputbuffer,"!",1) != 0)
|
|
{
|
|
/* determine the non-value portion of the
|
|
resource specification (i.e. the
|
|
part to the left of the ":" and to the
|
|
left of the first space).
|
|
*/
|
|
resource_end = DtStrchr(inputbuffer,':');
|
|
first_space = DtStrchr(inputbuffer,' ');
|
|
if (resource_end != NULL)
|
|
{
|
|
if ((first_space != NULL) &&
|
|
(first_space < resource_end))
|
|
|
|
{
|
|
resource_end = NULL;
|
|
}
|
|
}
|
|
if (resource_end != NULL)
|
|
{
|
|
*resource_end = '\0';
|
|
/* determine the start of each field
|
|
in the non-value part of the resource.
|
|
It is assumed that the individual fields
|
|
are delimited by a "*" or ".".
|
|
*/
|
|
field[0]=inputbuffer;
|
|
for (i=1;((i<NUMBER_OF_FIELDS) &&
|
|
(field[i-1] != NULL));
|
|
i++)
|
|
{
|
|
/* determine the location of the next
|
|
delimiter - "* or "."
|
|
Set field pointer to first one found.
|
|
*/
|
|
field[i]=DtStrchr(field[i-1],'*');
|
|
tmp1=DtStrchr(field[i-1],'.');
|
|
if (((tmp1 != NULL) && (tmp1 < resource_end) &&
|
|
(tmp1 < field[i])) ||
|
|
(field[i] == NULL))
|
|
{
|
|
field[i]=tmp1;
|
|
}
|
|
if (field[i] != NULL)
|
|
{
|
|
/* terminate the previous field */
|
|
*field[i] = '\0';
|
|
/* move pointer to start of field */
|
|
field[i]++;
|
|
}
|
|
if (field[i] >= resource_end)
|
|
{
|
|
field[i]=NULL;
|
|
}
|
|
}
|
|
number_fields = i-1;
|
|
/* check for each type of resource
|
|
that should be retained in the output file.
|
|
See comments preceding the definition
|
|
of each array near the start of this file
|
|
for a description and example of each type.
|
|
*/
|
|
if ((strlen(field[0]) == 0) &&
|
|
(number_fields == 2) &&
|
|
(check_match1(convert1,
|
|
NUMBER_OF_CONVERT1,1) == TRUE))
|
|
|
|
{
|
|
type_found=TRUE;
|
|
}
|
|
if ((type_found == FALSE) &&
|
|
(number_fields == 3) &&
|
|
(strcmp(field[0],CONVERT2_0) == 0) &&
|
|
(strcmp(field[1],CONVERT2_1) == 0) &&
|
|
(check_match1(convert2, NUMBER_OF_CONVERT2,2)
|
|
== TRUE))
|
|
{
|
|
type_found=TRUE;
|
|
}
|
|
if ((type_found == FALSE) &&
|
|
(number_fields == 2) &&
|
|
(check_match2(convert31,convert32,
|
|
NUMBER_OF_CONVERT3,0,1) == TRUE))
|
|
{
|
|
type_found=TRUE;
|
|
}
|
|
if ((type_found == FALSE) &&
|
|
(number_fields == 3) &&
|
|
(strcmp(field[2],CONVERT4_2) == 0) &&
|
|
(check_match1(convert4,
|
|
NUMBER_OF_CONVERT4,1) == TRUE))
|
|
{
|
|
type_found=TRUE;
|
|
}
|
|
if ((type_found == FALSE) &&
|
|
(number_fields == 3) &&
|
|
(strcmp(field[2],CONVERT5_2) == 0) &&
|
|
(check_match1(convert5,
|
|
NUMBER_OF_CONVERT5,0) == TRUE))
|
|
{
|
|
type_found=TRUE;
|
|
}
|
|
if ((type_found == FALSE) &&
|
|
(number_fields == 2) &&
|
|
(strlen(field[0]) > strlen(CONVERT6_0)) &&
|
|
(strncmp(field[0], CONVERT6_0,
|
|
strlen(CONVERT6_0)) == 0) &&
|
|
(check_match1(convert6,
|
|
NUMBER_OF_CONVERT6,1) == TRUE))
|
|
{
|
|
type_found=TRUE;
|
|
}
|
|
if ((type_found == FALSE) &&
|
|
(number_fields == 3) &&
|
|
((strcmp(field[0],CONVERT7_01) == 0) ||
|
|
(strcmp(field[0],CONVERT7_02) == 0)) &&
|
|
(check_match1(convert7,
|
|
NUMBER_OF_CONVERT7,2) == TRUE))
|
|
{
|
|
|
|
type_found=TRUE;
|
|
}
|
|
if ((type_found == FALSE) &&
|
|
(number_fields == 4) &&
|
|
((strcmp(field[0],CONVERT8_01) == 0) ||
|
|
(strcmp(field[0],CONVERT8_02) == 0)) &&
|
|
(check_match1(convert8,
|
|
NUMBER_OF_CONVERT8,3) == TRUE))
|
|
{
|
|
type_found=TRUE;
|
|
}
|
|
if ((type_found == FALSE) &&
|
|
(number_fields == 5) &&
|
|
((strcmp(field[0],CONVERT9_01) == 0) ||
|
|
(strcmp(field[0],CONVERT9_02) == 0)) &&
|
|
(check_match2(convert91,convert92,
|
|
NUMBER_OF_CONVERT9,3,4) == TRUE))
|
|
{
|
|
type_found=TRUE;
|
|
}
|
|
if ((type_found == FALSE) &&
|
|
(number_fields == 3) &&
|
|
(check_match1(convert10,
|
|
NUMBER_OF_CONVERT10,2) == TRUE))
|
|
{
|
|
type_found=TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* if resource should be retained then
|
|
write resource to output file.
|
|
*/
|
|
if (type_found == TRUE)
|
|
{
|
|
chars_written = fputs(unmodified_buffer,out_fh);
|
|
if (chars_written != strlen(unmodified_buffer))
|
|
{
|
|
if (rc == RC_SUCCESS)
|
|
{
|
|
rc = RC_WRITE_ERROR_TEMP;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} while (rc == RC_SUCCESS);
|
|
}
|
|
else
|
|
{
|
|
rc = RC_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
if (rc == RC_END_OF_FILE)
|
|
{
|
|
rc = RC_SUCCESS;
|
|
}
|
|
|
|
/* free all allocated buffers */
|
|
if (inputbuffer != NULL)
|
|
{
|
|
free(inputbuffer);
|
|
}
|
|
if (inputbuffer1 != NULL)
|
|
{
|
|
free(inputbuffer1);
|
|
}
|
|
if (unmodified_buffer != NULL)
|
|
{
|
|
free(unmodified_buffer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rc = RC_OPEN_ERROR;
|
|
}
|
|
if (in_fh != NULL)
|
|
{
|
|
fclose(in_fh);
|
|
}
|
|
if (out_fh != NULL)
|
|
{
|
|
fclose(out_fh);
|
|
}
|
|
return(rc);
|
|
}
|
|
|