← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/my_symlink2.c

  • Committer: Brian Aker
  • Date: 2008-10-06 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/my_symlink2.c
20
20
  rename files and symlinks like they would be one unit.
21
21
*/
22
22
 
23
 
#include "config.h"
24
 
 
25
 
#include "drizzled/internal/my_sys.h"
26
 
#include "drizzled/error.h"
27
 
#include "drizzled/internal/m_string.h"
28
 
 
29
 
namespace drizzled
30
 
{
31
 
namespace internal
32
 
{
33
 
 
34
 
int my_create_with_symlink(const char *linkname, const char *filename,
35
 
                           int createflags, int access_flags, myf MyFlags)
36
 
{
37
 
  int file;
 
23
#include "mysys_priv.h"
 
24
#include "mysys_err.h"
 
25
#include <mystrings/m_string.h>
 
26
 
 
27
File my_create_with_symlink(const char *linkname, const char *filename,
 
28
                            int createflags, int access_flags, myf MyFlags)
 
29
{
 
30
  File file;
38
31
  int tmp_errno;
39
32
  /* Test if we should create a link */
40
33
  int create_link;
41
34
  char abs_linkname[FN_REFLEN];
42
 
  char rp_buff[PATH_MAX];
43
35
 
44
36
  if (my_disable_symlinks)
45
37
  {
51
43
  else
52
44
  {
53
45
    if (linkname)
54
 
    {
55
 
      if (!realpath(linkname,rp_buff))
56
 
        my_load_path(rp_buff, linkname, NULL);
57
 
      rp_buff[FN_REFLEN-1]= '\0';
58
 
      strcpy(abs_linkname,rp_buff);
59
 
    }
 
46
      my_realpath(abs_linkname, linkname, MYF(0));
60
47
    create_link= (linkname && strcmp(abs_linkname,filename));
61
48
  }
62
49
 
64
51
  {
65
52
    if (!access(filename,F_OK))
66
53
    {
67
 
      errno= errno= EEXIST;
 
54
      my_errno= errno= EEXIST;
68
55
      my_error(EE_CANTCREATEFILE, MYF(0), filename, EEXIST);
69
56
      return(-1);
70
57
    }
71
58
    if (create_link && !access(linkname,F_OK))
72
59
    {
73
 
      errno= errno= EEXIST;
 
60
      my_errno= errno= EEXIST;
74
61
      my_error(EE_CANTCREATEFILE, MYF(0), linkname, EEXIST);
75
62
      return(-1);
76
63
    }
84
71
      if (MyFlags & MY_DELETE_OLD)
85
72
        my_delete(linkname, MYF(0));
86
73
      /* Create link */
87
 
      if (symlink(filename,linkname))
 
74
      if (my_symlink(filename, linkname, MyFlags))
88
75
      {
89
76
        /* Fail, remove everything we have done */
90
 
        tmp_errno=errno;
 
77
        tmp_errno=my_errno;
91
78
        my_close(file,MYF(0));
92
79
        my_delete(filename, MYF(0));
93
80
        file= -1;
94
 
        errno=tmp_errno;
 
81
        my_errno=tmp_errno;
95
82
      }
96
 
      else if (MyFlags & MY_SYNC_DIR)
97
 
        my_sync_dir_by_file(linkname, MyFlags);
98
83
    }
99
84
  }
100
85
  return(file);
108
93
int my_delete_with_symlink(const char *name, myf MyFlags)
109
94
{
110
95
  char link_name[FN_REFLEN];
111
 
  ssize_t sym_link_size= readlink(name,link_name,FN_REFLEN-1);
112
 
  int was_symlink= (!my_disable_symlinks && sym_link_size != -1);
 
96
  int was_symlink= (!my_disable_symlinks &&
 
97
                    !my_readlink(link_name, name, MYF(0)));
113
98
  int result;
114
99
 
115
100
  if (!(result=my_delete(name, MyFlags)))
116
101
  {
117
102
    if (was_symlink)
118
 
    {
119
 
      link_name[sym_link_size]= '\0';
120
 
      result= my_delete(link_name, MyFlags);
121
 
    }
 
103
      result=my_delete(link_name, MyFlags);
122
104
  }
123
105
  return(result);
124
106
}
135
117
 
136
118
int my_rename_with_symlink(const char *from, const char *to, myf MyFlags)
137
119
{
 
120
#ifndef HAVE_READLINK
 
121
  return my_rename(from, to, MyFlags);
 
122
#else
138
123
  char link_name[FN_REFLEN], tmp_name[FN_REFLEN];
139
 
  int sym_link_size= -1;
140
124
  int was_symlink= (!my_disable_symlinks &&
141
 
                   (sym_link_size= static_cast<int>(readlink(from,link_name,
142
 
                                                    FN_REFLEN-1))) != -1); 
 
125
                    !my_readlink(link_name, from, MYF(0)));
143
126
  int result=0;
144
127
  int name_is_different;
145
128
 
146
129
  if (!was_symlink)
147
130
    return(my_rename(from, to, MyFlags));
148
 
  else
149
 
    link_name[sym_link_size]= '\0';
150
131
 
151
132
  /* Change filename that symlink pointed to */
152
 
  strcpy(tmp_name, to);
 
133
  my_stpcpy(tmp_name, to);
153
134
  fn_same(tmp_name,link_name,1);                /* Copy dir */
154
135
  name_is_different= strcmp(link_name, tmp_name);
155
136
  if (name_is_different && !access(tmp_name, F_OK))
156
137
  {
157
 
    errno= EEXIST;
 
138
    my_errno= EEXIST;
158
139
    if (MyFlags & MY_WME)
159
140
      my_error(EE_CANTCREATEFILE, MYF(0), tmp_name, EEXIST);
160
141
    return(1);
161
142
  }
162
143
 
163
144
  /* Create new symlink */
164
 
  if (symlink(tmp_name, to))
 
145
  if (my_symlink(tmp_name, to, MyFlags))
165
146
    return(1);
166
 
  else if (MyFlags & MY_SYNC_DIR)
167
 
    my_sync_dir_by_file(to, MyFlags);
168
147
 
169
148
  /*
170
149
    Rename symlinked file if the base name didn't change.
174
153
 
175
154
  if (name_is_different && my_rename(link_name, tmp_name, MyFlags))
176
155
  {
177
 
    int save_errno=errno;
 
156
    int save_errno=my_errno;
178
157
    my_delete(to, MyFlags);                     /* Remove created symlink */
179
 
    errno=save_errno;
 
158
    my_errno=save_errno;
180
159
    return(1);
181
160
  }
182
161
 
183
162
  /* Remove original symlink */
184
163
  if (my_delete(from, MyFlags))
185
164
  {
186
 
    int save_errno=errno;
 
165
    int save_errno=my_errno;
187
166
    /* Remove created link */
188
167
    my_delete(to, MyFlags);
189
168
    /* Rename file back */
190
169
    if (strcmp(link_name, tmp_name))
191
170
      (void) my_rename(tmp_name, link_name, MyFlags);
192
 
    errno=save_errno;
 
171
    my_errno=save_errno;
193
172
    result= 1;
194
173
  }
195
174
  return(result);
 
175
#endif /* HAVE_READLINK */
196
176
}
197
 
 
198
 
} /* namespace internal */
199
 
} /* namespace drizzled */