← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_fopen.c

pandora-build v0.72 - Moved remaining hard-coded tests into pandora-build
macros.
Add PANDORA_DRIZZLE_BUILD to run the extra checks that drizzle needs that 
plugins would also need to run so we can just use that macro in generated
external plugin builds.
Added support to register_plugins for external plugin building.
Renamed register_plugins.py to pandora-plugin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_fopen.c
1
 
/* Copyright (C) 2000 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
16
 
#include "mysys_priv.h"
17
 
#include "my_static.h"
18
 
#include <errno.h>
19
 
#include "mysys_err.h"
20
 
 
21
 
static void make_ftype(char * to,int flag);
22
 
 
23
 
/*
24
 
  Open a file as stream
25
 
 
26
 
  SYNOPSIS
27
 
    my_fopen()
28
 
    FileName    Path-name of file
29
 
    Flags       Read | write | append | trunc (like for open())
30
 
    MyFlags     Flags for handling errors
31
 
 
32
 
  RETURN
33
 
    0   Error
34
 
    #   File handler
35
 
*/
36
 
 
37
 
FILE *my_fopen(const char *filename, int flags, myf MyFlags)
38
 
{
39
 
  FILE *fd;
40
 
  char type[5];
41
 
  /* 
42
 
    if we are not creating, then we need to use my_access to make sure  
43
 
    the file exists since Windows doesn't handle files like "com1.sym" 
44
 
    very  well 
45
 
  */
46
 
  {
47
 
    make_ftype(type,flags);
48
 
    fd = fopen(filename, type);
49
 
  }
50
 
  
51
 
  if (fd != 0)
52
 
  {
53
 
    /*
54
 
      The test works if MY_NFILE < 128. The problem is that fileno() is char
55
 
      on some OS (SUNOS). Actually the filename save isn't that important
56
 
      so we can ignore if this doesn't work.
57
 
    */
58
 
    if ((uint) fileno(fd) >= my_file_limit)
59
 
    {
60
 
      thread_safe_increment(my_stream_opened,&THR_LOCK_open);
61
 
      return(fd);                               /* safeguard */
62
 
    }
63
 
    pthread_mutex_lock(&THR_LOCK_open);
64
 
    if ((my_file_info[fileno(fd)].name = (char*)
65
 
         my_strdup(filename,MyFlags)))
66
 
    {
67
 
      my_stream_opened++;
68
 
      my_file_total_opened++;
69
 
      my_file_info[fileno(fd)].type = STREAM_BY_FOPEN;
70
 
      pthread_mutex_unlock(&THR_LOCK_open);
71
 
      return(fd);
72
 
    }
73
 
    pthread_mutex_unlock(&THR_LOCK_open);
74
 
    (void) my_fclose(fd,MyFlags);
75
 
    my_errno=ENOMEM;
76
 
  }
77
 
  else
78
 
    my_errno=errno;
79
 
  if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
80
 
    my_error((flags & O_RDONLY) || (flags == O_RDONLY ) ? EE_FILENOTFOUND :
81
 
             EE_CANTCREATEFILE,
82
 
             MYF(ME_BELL+ME_WAITTANG), filename, my_errno);
83
 
  return((FILE*) 0);
84
 
} /* my_fopen */
85
 
 
86
 
 
87
 
        /* Close a stream */
88
 
 
89
 
int my_fclose(FILE *fd, myf MyFlags)
90
 
{
91
 
  int err,file;
92
 
 
93
 
  pthread_mutex_lock(&THR_LOCK_open);
94
 
  file=fileno(fd);
95
 
  if ((err = fclose(fd)) < 0)
96
 
  {
97
 
    my_errno=errno;
98
 
    if (MyFlags & (MY_FAE | MY_WME))
99
 
      my_error(EE_BADCLOSE, MYF(ME_BELL+ME_WAITTANG),
100
 
               my_filename(file),errno);
101
 
  }
102
 
  else
103
 
    my_stream_opened--;
104
 
  if ((uint) file < my_file_limit && my_file_info[file].type != UNOPEN)
105
 
  {
106
 
    my_file_info[file].type = UNOPEN;
107
 
    my_free(my_file_info[file].name, MYF(MY_ALLOW_ZERO_PTR));
108
 
  }
109
 
  pthread_mutex_unlock(&THR_LOCK_open);
110
 
  return(err);
111
 
} /* my_fclose */
112
 
 
113
 
 
114
 
 
115
 
/*   
116
 
  Make a fopen() typestring from a open() type bitmap
117
 
 
118
 
  SYNOPSIS
119
 
    make_ftype()
120
 
    to          String for fopen() is stored here
121
 
    flag        Flag used by open()
122
 
 
123
 
  IMPLEMENTATION
124
 
    This routine attempts to find the best possible match 
125
 
    between  a numeric option and a string option that could be 
126
 
    fed to fopen.  There is not a 1 to 1 mapping between the two.  
127
 
  
128
 
  NOTE
129
 
    On Unix, O_RDONLY is usually 0
130
 
 
131
 
  MAPPING
132
 
    r  == O_RDONLY   
133
 
    w  == O_WRONLY|O_TRUNC|O_CREAT  
134
 
    a  == O_WRONLY|O_APPEND|O_CREAT  
135
 
    r+ == O_RDWR  
136
 
    w+ == O_RDWR|O_TRUNC|O_CREAT  
137
 
    a+ == O_RDWR|O_APPEND|O_CREAT
138
 
*/
139
 
 
140
 
static void make_ftype(register char * to, register int flag)
141
 
{
142
 
  /* check some possible invalid combinations */  
143
 
  assert((flag & (O_TRUNC | O_APPEND)) != (O_TRUNC | O_APPEND));
144
 
  assert((flag & (O_WRONLY | O_RDWR)) != (O_WRONLY | O_RDWR));
145
 
 
146
 
  if ((flag & (O_RDONLY|O_WRONLY)) == O_WRONLY)    
147
 
    *to++= (flag & O_APPEND) ? 'a' : 'w';  
148
 
  else if (flag & O_RDWR)          
149
 
  {
150
 
    /* Add '+' after theese */    
151
 
    if (flag & (O_TRUNC | O_CREAT))      
152
 
      *to++= 'w';    
153
 
    else if (flag & O_APPEND)      
154
 
      *to++= 'a';    
155
 
    else      
156
 
      *to++= 'r';
157
 
    *to++= '+';  
158
 
  }  
159
 
  else    
160
 
    *to++= 'r';
161
 
 
162
 
#if FILE_BINARY            /* If we have binary-files */  
163
 
  if (flag & FILE_BINARY)    
164
 
    *to++='b';
165
 
#endif  
166
 
  *to='\0';
167
 
} /* make_ftype */